private void MediaEngine_MediaStateChanged(MediaState state)
        {
            switch (state)
            {
                case MediaState.Loading:
                    this.PlaybackState = PlaybackState.Loading;

                    break;

                case MediaState.Stopped:
                    this.PlaybackState = PlaybackState.Paused;

                    break;

                case MediaState.Playing:
                    this.PlaybackState = PlaybackState.Playing;
                    break;

                case MediaState.Error:
                    this.PlaybackState = PlaybackState.Error_MediaInvalid;
                    break;

                case MediaState.Ended:
                    this.PlaybackState = PlaybackState.Ended;
                    break;
            }
        }

        public Sound(Game game)
        {
            this.game = game;

            music = new Music();
            soundEffect = new SoundEffect();
            state = new MediaState();
        }

 private void pauseSoundButton_Click(object sender, RoutedEventArgs e)
 {
     if (state == MediaState.Playing)
     {
         state = MediaState.Paused;
         myMediaElement.Pause();
     }
 }

 private void playSoundButton_Click(object sender, RoutedEventArgs e)
 {
     if ((state == MediaState.Stopped) || (state == MediaState.Paused))
     {
         state = MediaState.Playing;
         myMediaElement.Play();
     }
 }

        public static void Pause()
        {
			if (_song != null)
			{
				_song.Pause();
				_mediaState = MediaState.Paused;
			}			
        }

        public static void Resume()
        {
			if (_song != null)
			{
				_song.Resume();
				_mediaState = MediaState.Playing;
			}					
        }

        public VideoPlayer()
        {
			_state = MediaState.Stopped;
			_game = Game.Instance;
            _platform = (iOSGamePlatform)_game.Services.GetService(typeof(iOSGamePlatform));
            if (_platform == null)
                throw new InvalidOperationException("No iOSGamePlatform instance was available");
        }

 private void stopSoundButton_Click(object sender, RoutedEventArgs e)
 {
     if (state == MediaState.Playing)
     {
         state = MediaState.Stopped;
         myMediaElement.Stop();
     }
 }

 protected override void OnStateChanged(MediaState state)
 {
     if (state == MediaState.End) return;
     if (Album != null)
         Album.State = State;
     foreach (var artist in Artists)
         artist.State = state;
 }

        /*
        public Texture2D GetTexture()
        {
			// Coming Soon
			throw new NotImplementedException();
			// TODO when Xamarin implement the relevant functions return currentFrame;
        }
        */

        public void Pause()
        {
			if (_video != null )
			{
				_video.MovieView.Pause(new NSObject());
				_state = MediaState.Paused;
			}
        }

 private void playVideoButton_Click(object sender, RoutedEventArgs e)
 {
     if ((state == MediaState.Stopped) || (state == MediaState.Paused))
     {
         myMediaElement.Source = new Uri("ms-appx:///Assets/video.mp4", UriKind.RelativeOrAbsolute);
         state = MediaState.Playing;
         myMediaElement.Play();
     }
 }

        public static void Play(Song song)
        {
			if ( song != null )
			{
				_song = song;
				_song.Volume = _volume;
				_song.Loop = _looping;
				_song.Play();
				_mediaState = MediaState.Playing;
			}
        }

        public UmdDevice( IEmulationInstance emulator, ComponentParameters parameters )
        {
            //Debug.Assert( emulator != null );
            Debug.Assert( parameters != null );

            _emulator = emulator;
            _parameters = parameters;

            _state = MediaState.Ejected;

            _lbnLookup = new Dictionary<long, MediaFile>( 1024 );
        }

 public async void initValue()
 {
     musicList.Clear();
     await getFiles(musicList, folder);
     STT = 0;
     musicProperties = null;
     stream = null;
     state = MediaState.STOP;
     pb = Playback.ORDER;
     rp = Repeat.ALL;
     nof = NumOfLoad.FIRST;
 }

        public void SetVideoPlayerState(MediaState state)
        {
            switch(state)
            {
                case MediaState.Paused:
                    {
                        this._VideoPlayer.Pause();
                        break;
                    }

                case MediaState.Stopped:
                    {
                        this._VideoPlayer.Stop();
                        break;
                    }

                default:
                    break;
            }
        }

        private void PlatformGetState(ref MediaState result)
        {
            if (_clock != null)
            {
                ClockState state;
                _clock.GetState(0, out state);

                switch (state)
                {
                    case ClockState.Running:
                        result = MediaState.Playing;
                        return;

                    case ClockState.Paused:
                        result = MediaState.Paused;
                        return;
                }
            }

            result = MediaState.Stopped;
        }

        private void playVideoButton_Click(object sender, RoutedEventArgs e)
        {
          //myMediaElement.Source = new Uri("ms-appx:///Assets/coffee.mp4", UriKind.RelativeOrAbsolute);
          //myMediaElement.Play();

          if (state == MediaState.Stopped)
          {
            myMediaElement.Source = new Uri("ms-appx:///Assets/coffee.mp4", UriKind.RelativeOrAbsolute);
            state = MediaState.Playing;
            myMediaElement.Play();
          }
          else if (state == MediaState.Playing)
          {
            state = MediaState.Paused;
            myMediaElement.Pause();
          }
          else if (state == MediaState.Paused)
          {
            state = MediaState.Playing;
            myMediaElement.Play();
          }

        }

        public VideoPlayer(Game game)
        {
			_state = MediaState.Stopped;
			_game = game;
        }

        /// <inheritdoc /> 
        protected override void SetAdvertisingState(AdState adState)
#endif
        {
            var newValue = ConvertAdState(adState);
            var oldValue = MediaPlayer.AdvertisingState;

            if (newValue != oldValue)
            {
#if WINDOWS_PHONE7
                if (MediaPlayer.PlayerState == PlayerState.Started || playerState != null)
#else
                if (MediaPlayer.PlayerState == PlayerState.Started)
#endif
                {
                    // pause the MediaPlayer if we're playing a linear ad or loading an ad, resume if the opposite
                    if ((newValue == AdvertisingState.Loading || newValue == AdvertisingState.Linear) && (oldValue == AdvertisingState.None || oldValue == AdvertisingState.NonLinear))
                    {
#if WINDOWS_PHONE7
                        playerState = MediaPlayer.GetMediaState();
                        MediaPlayer.Close();
#else
                        MediaPlayer.Pause();
#endif
                    }
                    else if ((oldValue == AdvertisingState.Loading || oldValue == AdvertisingState.Linear) && (newValue == AdvertisingState.None || newValue == AdvertisingState.NonLinear))
                    {
#if WINDOWS_PHONE7
                        MediaPlayer.RestoreMediaState(playerState);
                        playerState = null;
#else
                        MediaPlayer.Play();
#endif
                    }
                }

                if (newValue == AdvertisingState.Loading)
                {
                    AdContainer.Visibility = Visibility.Visible;
                }
                else if (newValue == AdvertisingState.None)
                {
                    AdContainer.Visibility = Visibility.Collapsed;
                }

                // let the MediaPlayer update its visualstate
                MediaPlayer.AdvertisingState = newValue;
            }

            switch (newValue)
            {
                case AdvertisingState.Linear:
                    MediaPlayer.InteractiveViewModel = new VpaidLinearAdViewModel(ActiveAdPlayer, MediaPlayer);
                    break;
                case AdvertisingState.NonLinear:
                    MediaPlayer.InteractiveViewModel = new VpaidNonLinearAdViewModel(ActiveAdPlayer, MediaPlayer);
                    break;
                default:
                    MediaPlayer.InteractiveViewModel = MediaPlayer.DefaultInteractiveViewModel;
                    break;
            }
        }

 void Tcp_Server_StopVlc(object sender, System.Net.EndPoint e)
 {
     this.MediaState = MTC_Player.MediaState.Stop;
     this.mainClock.Controller.Pause();
     myVlcControl.Stop();
 }