public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { try { MediaElementState state = (MediaElementState)value; bool showProgress = false; switch (state) { case MediaElementState.AcquiringLicense: showProgress = true; break; case MediaElementState.Buffering: showProgress = true; break; case MediaElementState.Closed: showProgress = false; break; case MediaElementState.Individualizing: showProgress = true; break; case MediaElementState.Opening: showProgress = true; break; } return(showProgress); } catch (Exception err) { System.Diagnostics.Debug.WriteLine(err.Message); return(false); } }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); if (MediaElementState.Buffering == state && null != mediaElement1) { MediaStateBox.Text = string.Format("Buffering {0:F2}%", mediaElement1.BufferingProgress * 100); } else { MediaStateBox.Text = state.ToString(); } if (MediaElementState.Closed == state) { playButton.IsEnabled = true; stopButton.IsEnabled = false; } else if (MediaElementState.Paused == state || MediaElementState.Stopped == state) { playButton.IsEnabled = true; stopButton.IsEnabled = true; } else { stopButton.IsEnabled = true; } OnPositionSamplerOnTick(null, null); }
private static PlayerState GetPlayerState(MediaElementState state) { switch (state) { case MediaElementState.Playing: return(PlayerState.Playing); case MediaElementState.Paused: return(PlayerState.Paused); case MediaElementState.Stopped: return(PlayerState.Stopped); case MediaElementState.Buffering: return(PlayerState.Buffering); case MediaElementState.Opening: return(PlayerState.Opening); case MediaElementState.Closed: return(PlayerState.Closed); default: return(PlayerState.Other); } }
private void NativePlay() { if (this.NativeUIElement != null && !string.IsNullOrWhiteSpace(this.Source.OriginalString)) { if (!this.isApplyNewSource) { try { if (this.NativeUIElement != null && !string.IsNullOrWhiteSpace(this.Source.OriginalString)) { this.videoView.Prepare(); this.isApplyNewSource = true; } } catch (Exception e) { this.MediaFailed?.Invoke(this, new ExceptionRoutedEventArgs(e)); } } this.videoView.Play(); this.NativeCurrentState = MediaElementState.Playing; this.CurrentStateChanged?.Invoke(this, new RoutedEventArgs()); this.videoView.Completion -= MediaElement_Completion; this.videoView.Completion += MediaElement_Completion; } }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); //if (MediaElementState.Buffering == state && null != mediaElement1) //MediaStateBox.Text = string.Format("Buffering {0:F2}%", mediaElement1.BufferingProgress * 100); //else // MediaStateBox.Text = state.ToString(); switch (state) { case MediaElementState.Closed: PlayImg.Source = new BitmapImage(new Uri(playImg, UriKind.RelativeOrAbsolute)); break; case MediaElementState.Paused: PlayImg.Source = new BitmapImage(new Uri(playImg, UriKind.RelativeOrAbsolute)); break; case MediaElementState.Playing: bufferBor.Visibility = System.Windows.Visibility.Collapsed; PlayImg.Source = new BitmapImage(new Uri(pauseImg, UriKind.RelativeOrAbsolute)); break; default: break; } OnPositionSamplerOnTick(null, null); }
/// <summary> /// Event handling the fullscreen change event. /// </summary> /// <param name="sender">Sender of the event.</param> /// <param name="e">Event arguments.</param>> private void FullscreenChange(object sender, EventArgs e) { Application.Current.Host.Content.IsFullScreen = true; this.videoPosition = this.showcaseMediaPlayer.VideoPosition; this.volume = this.showcaseMediaPlayer.Volume; this.playerCurrentState = this.showcaseMediaPlayer.PlayerCurrentState; }
private void MediaElement_Completion(object sender, EventArgs e) { this.isApplyNewSource = false; this.NativeCurrentState = MediaElementState.Stopped; this.CurrentStateChanged?.Invoke(this, new RoutedEventArgs()); this.MediaEnded?.Invoke(this, new RoutedEventArgs()); }
public void ChangePlayState(MediaElementState mediaElementState) { switch (mediaElementState) { case MediaElementState.Paused: xMediaPlayer.Pause(); if (xMediaPlayer.CurrentState == MediaElementState.Playing || xMediaPlayer.CurrentState == MediaElementState.Buffering) { xPlayerControler.SetPlayerControlerBarStuas(MediaElementState.Paused); } break; case MediaElementState.Playing: xMediaPlayer.Play(); xPlayerControler.SetPlayerControlerBarStuas(MediaElementState.Playing); _timerOfControler.Start(); break; case MediaElementState.Stopped: xMediaPlayer.Stop(); break; default: break; } }
/// <summary> /// Waits for the MediaElement.CurrentState to change to any (default) or specific MediaElementState value. /// </summary> /// <param name="mediaElement"></param> /// <param name="newState">The MediaElementState value to wait for. Null by default causes the metod to wait for a change to any other state.</param> /// <returns></returns> public static async Task<MediaElement> WaitForStateAsync(this MediaElement mediaElement, MediaElementState? newState = null) { if (newState != null && mediaElement.CurrentState == newState.Value) { return null; } var tcs = new TaskCompletionSource<MediaElement>(); RoutedEventHandler reh = null; reh = (s, e) => { if (newState != null && mediaElement.CurrentState != newState.Value) { return; } mediaElement.CurrentStateChanged -= reh; tcs.SetResult((MediaElement)s); }; mediaElement.CurrentStateChanged += reh; return await tcs.Task; }
private void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); //if (MediaElementState.Buffering == state && null != TiviMediaElement) // //MediaStateBox.Text = string.Format("Buffering {0:F2}%", mediaElement1.BufferingProgress * 100); //else // //MediaStateBox.Text = state.ToString(); string str = "/Assets/Icon/transport.pause.png"; switch (state) { case MediaElementState.Paused: str = "/Assets/Icon/transport.play.png"; //errorBox.Visibility = Visibility.Collapsed; break; case MediaElementState.Playing: str = "/Assets/Icon/transport.pause.png"; //errorBox.Visibility = Visibility.Collapsed; break; default: str = "/Assets/Icon/transport.pause.png"; //errorBox.Visibility = Visibility.Collapsed; break; } var bmp = new BitmapImage(new Uri(str, UriKind.Relative)); imgPause.Source = bmp; OnPositionSamplerOnTick(null, null); }
public void SetPlayerControlerBarStuas(MediaElementState mediaElementState) { switch (mediaElementState) { case MediaElementState.Buffering: case MediaElementState.Opening: _isEnable = true; break; case MediaElementState.Closed: case MediaElementState.Stopped: _isEnable = false; break; case MediaElementState.Paused: _isEnable = true; xPauseButton.Visibility = Visibility.Collapsed; xPlayButton.Visibility = Visibility.Visible; break; case MediaElementState.Playing: _isEnable = true; xPauseButton.Visibility = Visibility.Visible; xPlayButton.Visibility = Visibility.Collapsed; break; default: break; } }
private void Button_Click(object sender, RoutedEventArgs e) { MediaElement temp = MainPage.Current.FindName("Scenario1MediaElement") as MediaElement; MediaElementState MediaElementState = temp.CurrentState; Frame scenarioFrame = MainPage.Current.FindName("ScenarioFrame") as Frame; scenarioFrame.Navigate(typeof(Video_Sample.AudioMainPage)); }
public static void ChangePlayState(MediaElementState mediaState) { System.Diagnostics.Debug.WriteLine(mediaState.ToString()); var playPage = CommonUtils.GetCurrentPage() as PlayPage; if (playPage != null) { playPage.ChangePlayState(mediaState); } }
void btnStop_Click(object sender, RoutedEventArgs e) { if (this.ClickPlayPauseStopButton != null) { this.currentState = MediaElementState.Stopped; this.ClickPlayPauseStopButton(this.currentState); this.btnPlayPuse.IsChecked = false; } }
private void NativeStop() { this.videoView.Completion -= MediaElement_Completion; this.videoView.Stop(); this.isApplyNewSource = false; this.NativeCurrentState = MediaElementState.Stopped; this.CurrentStateChanged?.Invoke(this, new RoutedEventArgs()); this.MediaEnded?.Invoke(this, new RoutedEventArgs()); }
private async Task UpdateState(MediaElementState state) { await DispatcherRunAsync(() => { if (CurrentState != state) { CurrentState = state; TransportControls?.UpdateState(state); } }); }
public override void InitAd(double width, double height, string viewMode, int desiredBitrate, string creativeData, string environmentVariables) { lastState = MediaElementState.Closed; base.Init(width, height, viewMode, desiredBitrate, creativeData, environmentVariables); MediaElement.Source = new Uri(creativeData); if (AdLinear) { LoadLinear(); } }
/// <summary> /// Fullscreen button key down. /// </summary> /// <param name="sender">Sender of the event.</param> private void BtnFullScreenKeyDown(object sender) { this.videoPosition = thePlayer.Position; this.volume = thePlayer.Volume; this.playerCurrentState = thePlayer.CurrentState; this.thePlayer.IsMuted = true; this.BtnMute.Opacity = 1; if (this.FullScreenEventHandler != null) { this.FullScreenEventHandler.Invoke(sender, null); } }
private async Task UpdateState(MediaElementState state) { await DispatcherRunAsync(() => { var previousState = CurrentState; if (previousState != state) { CurrentState = state; TransportControls?.UpdateState(previousState, state); } }); }
protected override void OnNavigatedTo(NavigationEventArgs e) { Grid gridMedia = MainPage.Current.FindName("GridMedia") as Grid; gridMedia.Visibility = Visibility.Collapsed; MediaElement mediaElement = MainPage.Current.FindName("Scenario1MediaElement") as MediaElement; MediaElementState temp = mediaElement.CurrentState; mediaElement.Pause(); MediaElementState temp1 = mediaElement.CurrentState; }
private void UpdateTransportControls(MediaElementState state) { nextButton.IsEnabled = true; prevButton.IsEnabled = true; if (state == MediaElementState.Playing) { playButton.Content = "| |"; // Change to pause button } else { playButton.Content = ">"; // Change to play button } }
private void UpdateTransportControls(MediaElementState state) { nextButton.IsEnabled = true; prevButton.IsEnabled = true; if (state == MediaElementState.Playing) { playButtonSymbol.Symbol = Symbol.Pause; } else { playButtonSymbol.Symbol = Symbol.Play; } }
Task GetStateChangedTask(MediaElementState state) { if (stateChangedTasks.ContainsKey(state)) { return(stateChangedTasks[state].Task); } else { var result = new TaskCompletionSource <object>(); stateChangedTasks.Add(state, result); return(result.Task); } }
/// <summary> /// Updates the state of the media /// </summary> /// <param name="previousState">previous state of the media element</param> /// <param name="state">state of the media element</param> internal void UpdateState(MediaElementState previousState, MediaElementState state) { string statusStateName, playPauseStateName, playPauseToolTip; switch (state) { case MediaElementState.Closed: case MediaElementState.Stopped: statusStateName = (HasError ? null : "Disabled"); playPauseStateName = "PlayState"; playPauseToolTip = "Play"; Clear(); break; case MediaElementState.Paused: statusStateName = "Disabled"; playPauseStateName = "PlayState"; playPauseToolTip = "Play"; break; case MediaElementState.Buffering: statusStateName = (previousState == MediaElementState.Playing || previousState == MediaElementState.Opening ? "Buffering" : null); playPauseStateName = null; playPauseToolTip = null; break; case MediaElementState.Playing: StartTimer(); goto default; default: statusStateName = "Normal"; playPauseStateName = "PauseState"; playPauseToolTip = "Pause"; break; } if (statusStateName != null) { HasError = false; VisualStateManager.GoToState(this, statusStateName, true); } if (playPauseStateName != null) { SetToolTip(PlayPauseButton, playPauseToolTip); SetToolTip(PlayPauseButtonOnLeft, playPauseToolTip); VisualStateManager.GoToState(this, playPauseStateName, true); } Show(); StartTimer(); }
void btnPlayPuse_Click(object sender, RoutedEventArgs e) { if (this.ClickPlayPauseStopButton != null) { if ((bool)(sender as ToggleButton).IsChecked) { this.currentState = MediaElementState.Playing; } else { this.currentState = MediaElementState.Paused; } this.ClickPlayPauseStopButton(this.currentState); } }
private void UpdateLockScreenPrevention(MediaElementState currentState) { if (currentState != MediaElementState.Playing) { if (_request == null) return; _request.RequestRelease(); _request = null; return; } if (_request != null) return; _request = new DisplayRequest(); _request.RequestActive(); }
void ControlMediaEnded(object sender, RoutedEventArgs e) { if (Element.IsLooping) { Control.Position = TimeSpan.Zero; Control.Play(); } else { _requestedState = MediaElementState.Stopped; Controller.CurrentState = MediaElementState.Stopped; Controller.OnMediaEnded(); } Controller.Position = Control.Position; }
/// <summary> /// Updates the state of the media /// </summary> /// <param name="state">state of the media element</param> internal void UpdateState(MediaElementState state) { string statusStateName, playPauseStateName, playPauseToolTip; switch (state) { case MediaElementState.Closed: case MediaElementState.Stopped: statusStateName = "Disabled"; playPauseStateName = "PlayState"; playPauseToolTip = "Play"; Clear(); break; case MediaElementState.Paused: statusStateName = "Disabled"; playPauseStateName = "PlayState"; playPauseToolTip = "Play"; break; case MediaElementState.Buffering: statusStateName = "Buffering"; playPauseStateName = null; playPauseToolTip = null; break; case MediaElementState.Playing: Timer.Start(); goto default; default: statusStateName = "Normal"; playPauseStateName = "PauseState"; playPauseToolTip = "Pause"; break; } VisualStateManager.GoToState(this, statusStateName, true); if (playPauseStateName != null) { SetToolTip(PlayPauseButton, playPauseToolTip); SetToolTip(PlayPauseButtonOnLeft, playPauseToolTip); VisualStateManager.GoToState(this, playPauseStateName, true); } Show(); StartTimer(); }
void playTools_ClickPlayPauseStopButton(MediaElementState state) { switch (state) { case MediaElementState.Playing: this.mediaElement.Play(); break; case MediaElementState.Paused: this.mediaElement.Pause(); break; case MediaElementState.Stopped: this.mediaElement.Stop(); break; } }
void ControlMediaOpened(object sender, RoutedEventArgs e) { Controller.Duration = Control.NaturalDuration.HasTimeSpan ? Control.NaturalDuration.TimeSpan : (TimeSpan?)null; Controller.VideoHeight = Control.NaturalVideoHeight; Controller.VideoWidth = Control.NaturalVideoWidth; Controller.OnMediaOpened(); if (Element.AutoPlay) { Control.Play(); _requestedState = MediaElementState.Playing; Controller.CurrentState = MediaElementState.Playing; } else { Controller.CurrentState = _requestedState; } }
public void UpdatePosition(PlaylistMgr Playlist, TimeSpan CurrentPosition, MediaElementState State) { if (_isUpdating) return; _isUpdating = true; int AvailableChunkCount = Playlist.AvailableChunkCount; _lastTotalPlayLength = Playlist.PlaylistDuration; ChunkSlider.AvailableChunkCount = AvailableChunkCount; ChunkSlider.ChunkDuration = Playlist.ChunkDuration; if (CurrentPosition == TimeSpan.Zero) { TimeTextBox.Text = "Loading"; } else { TimeTextBox.Text = State.ToString() + " " + FormatTimeSpan(CurrentPosition); ChunkSlider.UpdatePlayhead(Playlist, CurrentPosition); } _isUpdating = false; }
void xPlayerControlBar_MediaElementStatusChanged(object sender, MediaElementState mediaElementState) { switch (mediaElementState) { case MediaElementState.Paused: xPPvodWP7MediaElement.Pause(); break; case MediaElementState.Playing: { if (_playLocalFile) { xPPvodWP7MediaElement.Play(); break; } if (ChannelDetailInfo != null && (_currentPlayBitrate != null && string.IsNullOrEmpty(_currentPlayBitrate.Rid) == false && _currentPlayBitrate.Rid != "null") && string.IsNullOrEmpty(xPPvodWP7MediaElement.OriSource.Rid) == false) { xPPvodWP7MediaElement.Play(); } else { BeginGetInfoNPlay(); } Utils.PlayInfo playInfo = new Utils.PlayInfo(); playInfo.stopReason = 1; } break; case MediaElementState.Stopped: xPPvodWP7MediaElement.Stop(); break; case MediaElementState.Buffering: break; default: break; } }
void ElementStateRequested(object sender, StateRequested e) { _requestedState = e.State; switch (e.State) { case MediaElementState.Playing: if (Element.KeepScreenOn) { DisplayRequestActive(); } Control.Play(); Controller.CurrentState = _requestedState; break; case MediaElementState.Paused: if (Control.CanPause) { if (Element.KeepScreenOn) { DisplayRequestRelease(); } Control.Pause(); Controller.CurrentState = _requestedState; } break; case MediaElementState.Stopped: if (Element.KeepScreenOn) { DisplayRequestRelease(); } Control.Stop(); Controller.CurrentState = _requestedState; break; } Controller.Position = Control.Position; }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); if (MediaElementState.Buffering == state && null != mediaElement1) MediaStateBox.Text = string.Format("Buffering {0:F2}%", mediaElement1.BufferingProgress * 100); else MediaStateBox.Text = state.ToString(); var smtc = SystemMediaTransportControls.GetForCurrentView(); switch (state) { case MediaElementState.Closed: playButton.IsEnabled = true; stopButton.IsEnabled = false; smtc.PlaybackStatus = MediaPlaybackStatus.Closed; break; case MediaElementState.Paused: playButton.IsEnabled = true; stopButton.IsEnabled = true; smtc.PlaybackStatus = MediaPlaybackStatus.Paused; break; case MediaElementState.Playing: playButton.IsEnabled = false; stopButton.IsEnabled = true; smtc.PlaybackStatus = MediaPlaybackStatus.Playing; break; case MediaElementState.Stopped: playButton.IsEnabled = true; stopButton.IsEnabled = true; smtc.PlaybackStatus = MediaPlaybackStatus.Stopped; break; default: stopButton.IsEnabled = true; break; } if (null == mediaElement1) _wasFull = false; else { if (MediaElementState.Playing == state) { if (_wasFull) mediaElement1.IsFullWindow = true; } else { _wasFull = mediaElement1.IsFullWindow; if (_wasFull) mediaElement1.IsFullWindow = false; } } OnPositionSamplerOnTick(null, null); }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); }
public void ChangePlayState(MediaElementState mediaElementState) { switch (mediaElementState) { case MediaElementState.Paused: xMediaPlayer.Pause(); if (xMediaPlayer.CurrentState == MediaElementState.Playing || xMediaPlayer.CurrentState == MediaElementState.Buffering) xPlayerControler.SetPlayerControlerBarStuas(MediaElementState.Paused); break; case MediaElementState.Playing: xMediaPlayer.Play(); xPlayerControler.SetPlayerControlerBarStuas(MediaElementState.Playing); _timerOfControler.Start(); break; case MediaElementState.Stopped: xMediaPlayer.Stop(); break; default: break; } }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); if (MediaElementState.Buffering == state && null != mediaElement1) MediaStateBox.Text = string.Format("Buffering {0:F2}%", mediaElement1.BufferingProgress * 100); else MediaStateBox.Text = state.ToString(); switch (state) { case MediaElementState.Closed: playButton.IsEnabled = true; stopButton.IsEnabled = false; break; case MediaElementState.Paused: playButton.IsEnabled = true; stopButton.IsEnabled = true; errorBox.Visibility = Visibility.Collapsed; break; case MediaElementState.Playing: playButton.IsEnabled = false; stopButton.IsEnabled = true; errorBox.Visibility = Visibility.Collapsed; break; default: stopButton.IsEnabled = true; errorBox.Visibility = Visibility.Collapsed; break; } OnPositionSamplerOnTick(null, null); }
protected virtual void OnMediaCurrentStateChanged(MediaElementState currentState) { // update buffering display UpdateBufferingState(); switch (mediaElement.CurrentState) { case MediaElementState.Playing: if (playElement != null) playElement.CurrentPlayState = PlayState.Playing; statusTimer.Start(); pollingTimer.Start(); UpdateDisplay(); break; case MediaElementState.Paused: if (playElement != null) playElement.CurrentPlayState = PlayState.Paused; UpdateDisplay(); pollingTimer.Stop(); break; case MediaElementState.Stopped: if (playElement != null) playElement.CurrentPlayState = PlayState.Stopped; pollingTimer.Stop(); break; case MediaElementState.Buffering: // don't update the play state for buffering break; default: if (playElement != null) playElement.CurrentPlayState = PlayState.Paused; break; } }
void xPlayerControlBar_MediaElementStatusChanged(object sender, MediaElementState mediaElementState) { switch (mediaElementState) { case MediaElementState.Paused: xPPvodWP7MediaElement.Pause(); break; case MediaElementState.Playing: { if (_playLocalFile) { xPPvodWP7MediaElement.Play(); break; } if (ChannelDetailInfo != null && (_currentPlayBitrate != null && string.IsNullOrEmpty(_currentPlayBitrate.Rid) == false && _currentPlayBitrate.Rid != "null") && string.IsNullOrEmpty(xPPvodWP7MediaElement.OriSource.Rid) == false) xPPvodWP7MediaElement.Play(); else BeginGetInfoNPlay(); Utils.PlayInfo playInfo = new Utils.PlayInfo(); playInfo.stopReason = 1; } break; case MediaElementState.Stopped: xPPvodWP7MediaElement.Stop(); break; case MediaElementState.Buffering: break; default: break; } }
protected MediaElementAdapterState ConvertToMediaElementAdapterState(MediaElementState currentState) { DebugTrace("[ConvertToMediaElementAdapterState] CurrentState={0}", currentState); switch (currentState) { case MediaElementState.Closed: return MediaElementAdapterState.Closed; case MediaElementState.Opening: return MediaElementAdapterState.Closed; // need to go closed while opening so we cancel scrubbing case MediaElementState.Buffering: return MediaElementAdapterState.Busy; case MediaElementState.Playing: return MediaElementAdapterState.Playing; case MediaElementState.Paused: return MediaElementAdapterState.Paused; case MediaElementState.Stopped: return MediaElementAdapterState.Stopped; case MediaElementState.Individualizing: return MediaElementAdapterState.Busy; case MediaElementState.AcquiringLicense: return MediaElementAdapterState.Busy; default: throw new ArgumentOutOfRangeException("currentState"); } }
/// <summary> /// Delegate function which tracks the state of the media element /// </summary> /// <param name="sender">the object which sent this event</param> /// <param name="e">event args</param> private void MediaElementCurrentStateChanged(object sender, RoutedEventArgs e) { m_mediaElementState = (sender as MediaElement).CurrentState; }
void UpdateState(MediaElementState state) { Debug.WriteLine("MediaElement State: " + state); if (MediaElementState.Closed == state) OnStop(); else OnPlay(); }
public void SetState(MediaElementState mediaState) { Context.CurrentState = Factory.SetState(mediaState, Context); }
void OnAdPlayerCurrentStateChanged(object sender, RoutedEventArgs e) { if (lastState == MediaElement.CurrentState) return; switch (MediaElement.CurrentState) { case MediaElementState.Paused: if (IsPaused) { OnAdPaused(); } break; case MediaElementState.Playing: if (IsResumed) { OnAdResumed(); } else if (IsStopped) { OnAdStarted(); StartVideo(); } break; } if (MediaElement != null) { OnAdLog(new AdMessageEventArgs(string.Format("Status changed from {0} to {1}", lastState, MediaElement.CurrentState))); //ignore these types, they arent relevent if (!(MediaElement.CurrentState == MediaElementState.Buffering || MediaElement.CurrentState == MediaElementState.AcquiringLicense || MediaElement.CurrentState == MediaElementState.Individualizing)) { lastState = MediaElement.CurrentState; } } }
void xPlayerControler_MediaElementStatusChanged(object sender, MediaElementState mediaElementState) { ChangePlayState(mediaElementState); }
//========================================================================== private void OnStateChanged(MediaElementState oldValue, MediaElementState newValue) { // ... }
private static MediaPluginState ConvertToPlayState(MediaElementState mediaElementState) { return (MediaPluginState)Enum.Parse(typeof(MediaPluginState), mediaElementState.ToString(), true); }
MediaElementAdapterState ConvertToState(MediaElementState state) { switch (state) { case MediaElementState.AcquiringLicense: return MediaElementAdapterState.Busy; case MediaElementState.Buffering: return MediaElementAdapterState.Busy; case MediaElementState.Closed: return MediaElementAdapterState.Closed; case MediaElementState.Individualizing: return MediaElementAdapterState.Busy; case MediaElementState.Opening: return MediaElementAdapterState.Busy; case MediaElementState.Paused: return MediaElementAdapterState.Paused; case MediaElementState.Playing: return MediaElementAdapterState.Playing; case MediaElementState.Stopped: return MediaElementAdapterState.Stopped; default: throw new NotImplementedException(); } }
Task GetStateChangedTask(MediaElementState state) { if (stateChangedTasks.ContainsKey(state)) { return stateChangedTasks[state].Task; } else { var result = new TaskCompletionSource<object>(); stateChangedTasks.Add(state, result); return result.Task; } }