public override StartVideoPlaybackMessage GetStartVideoPlaybackMessageWithCurrentPosition(MediaPlayer mediaPlayer)
        {
            var message = base.GetStartVideoPlaybackMessageWithCurrentPosition(mediaPlayer);
            message.FullScreen = false;

            return message;
        }

		protected override void OnCreate(Bundle bundle)
		{
			base.OnCreate(bundle);

			this.SetContentView(Resource.Layout.Main);

			var playButton = this.FindViewById<Button>(Resource.Id.PlayPauseButton);
			var stopButton = this.FindViewById<Button>(Resource.Id.StopButton);
			var searchView = this.FindViewById<SearchView>(Resource.Id.SearchView);
			this.listView = this.FindViewById<ListView>(Resource.Id.listView1);
			this.timeDisplay = this.FindViewById<TextView>(Resource.Id.TimeDisplay);
			this.adapter = new SongResultsAdapter(this, new Song[0]);
			this.player = new MediaPlayer();
			
			this.switcher = this.FindViewById<ViewSwitcher>(Resource.Id.ViewSwitcher);
			this.loadingMessage = this.FindViewById<TextView>(Resource.Id.LoadingMessage);
			
			playButton.Click += this.PlayButton_Click;
			stopButton.Click += this.StopButton_Click;
			searchView.QueryTextSubmit += this.SearchView_QueryTextSubmit;
			searchView.QueryTextChange += this.SearchView_QueryTextChange;
			this.listView.ItemClick += this.ListView_ItemClick;
			this.player.BufferingUpdate += this.Player_BufferingUpdate;
			this.player.Error += this.Player_Error;

			this.ShowListViewMessage("Write in the search box to start.");
		}

        // Media set up

        //------------------------------------------------------------------------------
        //
        // StartPlayback
        //
        // News up a MediaPlayer, creates a playback item then 
        // MediaPlayer hands out a surface that can be put on brush
        // We call this below when we set up the tree init the composition
        //
        //------------------------------------------------------------------------------
        private void StartPlayback()
        {


            // MediaPlayer set up with a create from URI
            _mediaPlayer = new MediaPlayer();

            // Get a source from a URI. This could also be from a file via a picker or a stream

            var source = MediaSource.CreateFromUri(new Uri("http://go.microsoft.com/fwlink/?LinkID=809007&clcid=0x409"));
            var item = new MediaPlaybackItem(source);
            _mediaPlayer.Source = item;

            // MediaPlayer supports many of the starndard MediaElement vars like looping
            _mediaPlayer.IsLoopingEnabled = true;

            // Get the surface from MediaPlayer and put it on a brush
            _videoSurface = _mediaPlayer.GetSurface(_compositor);
            _videoVisual.Brush = _compositor.CreateSurfaceBrush(_videoSurface.CompositionSurface);

            // Play the video on app run.

            PlayVideo();

        }

        public WindowsMediaPlayerModel()
        {
            _mediaPlayer = new MediaPlayer();
            IsPlaying = false;

            _mediaPlayer.MediaEnded += (sender, args) => Stop();
        }

        void HandleMediaPlayerMediaOpened(MediaPlayer sender, object args)
        {
            if (isFirstOpen)
            {
                isFirstOpen = false;
                double percentage = ApplicationSettings.GetSettingsValue<double>(ApplicationSettings.CURRENT_TRACK_PERCENTAGE, 0.0);
                ApplicationSettings.PutSettingsValue(ApplicationSettings.CURRENT_TRACK_PERCENTAGE, 0.0);

                if (percentage > 0)
                {
                    Logger.Current.Init(LogType.PlayAction);

                    Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Length Total {0}", mediaPlayer.NaturalDuration.Ticks);

                    mediaPlayer.Position = TimeSpan.FromTicks((long)(mediaPlayer.NaturalDuration.Ticks * percentage));
                }
            }

            int trackId = ApplicationSettings.GetSettingsValue<int>(ApplicationSettings.CURRENT_PLAYQUEUE_POSITION, 0);
            Logger.Current.Init(LogType.PlayAction);

            Logger.Current.Log(new CallerInfo(), LogLevel.Info, "Trying to play row {0}", trackId);

            playingTrack = TrackInfo.TrackInfoFromRowId(trackId);
            TrackChanged.Invoke(this, playingTrack);

            if (playAfterOpen)
            {
                sender.Play();
            }
            else
            {
                playAfterOpen = true;
            }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        internal MediaEventsHelper(MediaPlayer mediaPlayer) 
        {
            _mediaOpened = new DispatcherOperationCallback(OnMediaOpened); 
            this.DispatcherMediaOpened += _mediaOpened; 

            _mediaFailed = new DispatcherOperationCallback(OnMediaFailed); 
            this.DispatcherMediaFailed += _mediaFailed;

            _mediaPrerolled = new DispatcherOperationCallback(OnMediaPrerolled);
            this.DispatcherMediaPrerolled += _mediaPrerolled; 

            _mediaEnded = new DispatcherOperationCallback(OnMediaEnded); 
            this.DispatcherMediaEnded += _mediaEnded; 

            _bufferingStarted = new DispatcherOperationCallback(OnBufferingStarted); 
            this.DispatcherBufferingStarted += _bufferingStarted;

            _bufferingEnded = new DispatcherOperationCallback(OnBufferingEnded);
            this.DispatcherBufferingEnded += _bufferingEnded; 

            _scriptCommand = new DispatcherOperationCallback(OnScriptCommand); 
            this.DispatcherScriptCommand += _scriptCommand; 

            _newFrame = new DispatcherOperationCallback(OnNewFrame); 
            this.DispatcherMediaNewFrame += _newFrame;

            SetSender(mediaPlayer);
        } 

        /// <summary>
        /// A media player that takes control of a NotifyIcon icon,
        /// tooltip and balloon to display status.
        /// </summary>
        /// <param name="icon">
        /// The notify icon to use to display status.
        /// </param>
        public Player(NotifyIcon icon)
        {
            notifyIcon = icon;

            player = new MediaPlayer();
            player.BufferingStarted += OnBufferingStarted;
            player.BufferingEnded += OnBufferingEnded;
            player.MediaEnded += OnMediaEnded;
            player.MediaFailed += OnMediaFailed;

            idleIcon = Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Idle.ico");
            playingIcon = Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Playing.ico");
            playingMutedIcon = Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Playing-muted.ico");

            bufferingIcons = new Icon[] {
                Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Buffering1.ico"),
                Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Buffering2.ico"),
                Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Buffering3.ico"),
                Util.ResourceAsIcon("GaGa.NotifyIconPlayer.Resources.Buffering4.ico"),
            };

            bufferingIconTimer = new DispatcherTimer(DispatcherPriority.Background);
            bufferingIconTimer.Interval = TimeSpan.FromMilliseconds(300);
            bufferingIconTimer.Tick += OnBufferingIconTimerTick;
            currentBufferingIcon = 0;

            source = null;
            isIdle = true;

            UpdateIcon();
        }

 public static void RunTests() {
     var player = new MediaPlayer();
     player.Play();
     player.Pause();
     player.Stop();
     player.AllSongs.TrackNames.PrintCollection();
 }

 public MainPage()
 {
     this.InitializeComponent();
     this.NavigationCacheMode = NavigationCacheMode.Required;
     initValue();
     mediaPlayer = BackgroundMediaPlayer.Current;
 }

        public MainWindow()
        {
            InitializeComponent();

            OscServer oscServer;
            
            oscServer = new OscServer(TransportType.Udp, IPAddress.Loopback, Port);

            oscServer.FilterRegisteredMethods = false;
			oscServer.RegisterMethod(AliveMethod);
            oscServer.RegisterMethod(TestMethod);
            oscServer.BundleReceived += new EventHandler<OscBundleReceivedEventArgs>(oscServer_BundleReceived);
			oscServer.MessageReceived += new EventHandler<OscMessageReceivedEventArgs>(oscServer_MessageReceived);
            oscServer.ReceiveErrored += new EventHandler<Bespoke.Common.ExceptionEventArgs>(oscServer_ReceiveErrored);
            oscServer.ConsumeParsingExceptions = false;

            oscServer.Start();
            Console.WriteLine("Server started.");

            //Start playing audio
            string audioFileName = "/file/path";
            mp = new MediaPlayer();
            mp.MediaOpened += new EventHandler(mp_MediaOpened);
            bool isPaused = false;
            bool isPlaying = false;
        }

        protected override void OnCreate (Bundle bundle)
        {
            base.OnCreate (bundle);

            // Set our view from the "main" layout resource
            SetContentView (Resource.Layout.Main);

            if(mLibVLC == null)
            {
                mLibVLC = new LibVLCLibVLC();
                mMediaPlayer = new MediaPlayer(mLibVLC);
            }

            // Get our button from the layout resource,
            // and attach an event to it
            Button button = FindViewById<Button> (Resource.Id.myButton);

            button.Click += delegate {
                button.Text = string.Format ("{0} clicks!", count++);

                var m = new MediaLibVLC(mLibVLC, Android.Net.Uri.Parse("http://www.montemagno.com/sample.mp3"));

                // Tell the media player to play the new Media.
                mMediaPlayer.Media = m;

                // Finally, play it!
                mMediaPlayer.Play();
            };
        }

        /// <summary>
        /// Pause
        /// </summary>
        private void Pause()
        {
            if (_mediaPlayer == null)
                _mediaPlayer = BackgroundMediaPlayer.Current;

            _mediaPlayer.Pause();
        }

        public void SetUpProtectionManager(MediaPlayer mediaPlayer)
        {
            Log("Enter SetUpProtectionManager");

            if(mediaPlayer == null)
                throw new ArgumentException("SetUpProtectionManager was passed a null MediaPlayer");
            
            Log("Creating protection system mappings...");
            var protectionManager = new MediaProtectionManager();

            protectionManager.ComponentLoadFailed += new ComponentLoadFailedEventHandler(ProtectionManager_ComponentLoadFailed);
            protectionManager.ServiceRequested += new ServiceRequestedEventHandler(ProtectionManager_ServiceRequested);

            // The code here is mandatory and should be just copied directly over to the app
            // Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/aa376846%28v=vs.85%29.aspx

            // Setup PlayReady as the ProtectionSystem to use by mediaFoundation: 
            var contentProtectionSystems = new PropertySet();
            contentProtectionSystems.Add(PlayReadyWinRTTrustedInput);
            protectionManager.Properties.Add(MediaProtectionSystemIdMapping, contentProtectionSystems);
            protectionManager.Properties.Add(MediaProtectionSystemId);
            protectionManager.Properties.Add(MediaProtectionContainerGuid);

            mediaPlayer.ProtectionManager = protectionManager;

            Log("Leave SetUpProtectionManager");
        }

 public Mp3PlayerPlugin()
 {
     player = new MediaPlayer();
     player.Volume = 100;
     FriendlyName = "Basic Mp3 Player";
     FriendlyStatus = "TODO: Return Current Status";
 }

 public void load(MediaPlayer mp,String file)
 {
     mp.Position = TimeSpan.Zero;
     string url = @"C:\Users\Asura\Documents\Visual Studio 2012\Projects\Project Labyrinth(C-Sharp)\Pro Labyrinth(C-Sharp)\Sound\"+file+".wav";
     mp.Open(new Uri(url, UriKind.Relative));
     mp.Volume = 100;
 }

 public void Play(string filename, Action<Exception> failed = null)
 {
     Application.Current.Dispatcher.BeginInvoke(new Action(() =>
     {
         try
         {
             var path = string.Format(soundFilePath, "wav", filename);
             if (!System.IO.File.Exists(path))
             {
                 path = string.Format(soundFilePath, "mp3", filename);
             }
             if (!System.IO.File.Exists(path))
             {
                 throw new System.IO.FileNotFoundException();
             }
             if (mediaPlayer == null)
             {
                 mediaPlayer = new MediaPlayer { Volume = 1 };
             }
             mediaPlayer.Open(new Uri(path, UriKind.Absolute));
             mediaPlayer.Play();
         }
         catch (Exception ex)
         {
             AMing.Plugins.Core.GenericMessager.Current.SendToException(ex);
             if (failed != null)
                 failed(ex);
         }
     }));
 }

		private void PlayVideo ()
		{
			try {
				if (path == "") {
					// Tell the user to provide an audio file URL.
					Toast.MakeText (this, "Please edit MediaPlayer Activity, " + "and set the path variable to your media file path." + " Your media file must be stored on sdcard.", ToastLength.Long).Show ();
					return;
				}
				mediaPlayer = new MediaPlayer (this);
				mediaPlayer.SetDataSource (path);
				mediaPlayer.SetDisplay (sholder);
				mediaPlayer.PrepareAsync ();
				mediaPlayer.SetOnPreparedListener (this);

				mediaPlayer.SetOnTimedTextListener (this);

				// TODO Auto-generated catch block
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.PrintStackTrace ();
			} catch (IllegalStateException e) {
				// TODO Auto-generated catch block
				e.PrintStackTrace ();
			} catch (SecurityException e) {
				// TODO Auto-generated catch block
				e.PrintStackTrace ();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.PrintStackTrace ();
			}
		}

		public bool OnInfo (MediaPlayer mp, int what, int extra)
		{
			switch (what) {
			case MediaPlayer.MediaInfoBufferingStart:
				if (mVideoView.IsPlaying) {
					mVideoView.Pause ();
					pb.Visibility = ViewStates.Visible;
					downloadRateView.Text = "";
					loadRateView.Text = "";
					downloadRateView.Visibility = ViewStates.Visible;
					loadRateView.Visibility = ViewStates.Visible;

				}
				break;
			case MediaPlayer.MediaInfoBufferingEnd:
				mVideoView.Start ();
				pb.Visibility = ViewStates.Gone;
				downloadRateView.Visibility = ViewStates.Gone;
				loadRateView.Visibility = ViewStates.Gone;
				break;
			case MediaPlayer.MediaInfoDownloadRateChanged:
				downloadRateView.Text = "" + extra + "kb/s" + "  ";
				break;
			}
			return true;
		}

        public MainWindow()
        {
            InitializeComponent();
            _thisWindow = this;
            BackgroundMusicPlayer = new MediaPlayer();

            #region Music Stuff

            var uri = new Uri(BasePath, "Resources/intro.mp3");
            var mediaPlayer = MainWindow.BackgroundMusicPlayer;
            mediaPlayer.Open(uri);
            mediaPlayer.Play();

            #endregion

            CharacterSelect selectScreen = new CharacterSelect();

            selectScreen.ShowDialog();

            #region Music Stuff

            uri = new Uri(BasePath, "Resources/soundtrack.mp3");
            mediaPlayer.Open(uri);
            mediaPlayer.Play();
            BackgroundPosition = mediaPlayer.Position;

            #endregion

            Start();
        }

 /// <summary>
 /// Fired when MediaPlayer is ready to play the track
 /// </summary>
 void MediaPlayer_MediaOpened(MediaPlayer sender, object args)
 {
     // wait for media to be ready
     sender.Play();
     Debug.WriteLine("New Track" + this.CurrentTrackName);
     TrackChanged.Invoke(this, CurrentTrackName);
 }