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;
}
}
public static void ChangePlayState(MediaElementState mediaState)
{
System.Diagnostics.Debug.WriteLine(mediaState.ToString());
var playPage = CommonUtils.GetCurrentPage() as PlayPage;
if (playPage != null)
{
playPage.ChangePlayState(mediaState);
}
}
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);
}
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);
}
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;
}
}
private void UpdateTransportControls(MediaElementState state)
{
nextButton.IsEnabled = true;
prevButton.IsEnabled = true;
if (state == MediaElementState.Playing)
{
playButtonSymbol.Symbol = Symbol.Pause;
}
else
{
playButtonSymbol.Symbol = Symbol.Play;
}
}
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);
}
}
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 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;
}
}
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 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 xPlayerControler_MediaElementStatusChanged(object sender, MediaElementState mediaElementState)
{
ChangePlayState(mediaElementState);
}
//==========================================================================
private void OnStateChanged(MediaElementState oldValue, MediaElementState newValue)
{
// ...
}
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 static MediaPluginState ConvertToPlayState(MediaElementState mediaElementState)
{
return (MediaPluginState)Enum.Parse(typeof(MediaPluginState), mediaElementState.ToString(), true);
}
void btnStop_Click(object sender, RoutedEventArgs e)
{
if (this.ClickPlayPauseStopButton != null)
{
this.currentState = MediaElementState.Stopped;
this.ClickPlayPauseStopButton(this.currentState);
this.btnPlayPuse.IsChecked = false;
}
}
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();
}
}
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
}
}
/// <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;
}
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;
}
}
