public async Task Play(IMediaFile mediaFile = null)
{
try
{
var sameMediaFile = mediaFile == null || mediaFile.Equals(_currentMediaFile);
if (Status == MediaPlayerStatus.Paused && sameMediaFile)
{
_player.PlaybackSession.PlaybackRate = 1;
_player.Play();
return;
}
if (mediaFile != null)
{
_currentMediaFile = mediaFile;
var mediaPlaybackList = new MediaPlaybackList();
var mediaSource = await CreateMediaSource(mediaFile);
var item = new MediaPlaybackItem(mediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
}
catch (Exception e)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs("Unable to start playback", e));
Status = MediaPlayerStatus.Stopped;
}
}
private void OnMediaFailed(MediaPlayer sender, MediaPlayerFailedEventArgs args)
{
if (ApiInfo.IsPhoneContractPresent &&
sender.Source is MediaSource source &&
source.CustomProperties.TryGet("alternativeMimeTypeSource", out MediaSource guessedMimeTypeSource) &&
guessedMimeTypeSource != null && CurrentPlayback.Source.Equals(source) &&
source.CustomProperties.TryGet("file", out int fileId) &&
source.CustomProperties.TryGet("message", out long messageId) &&
source.CustomProperties.TryGet("chat", out long chatId) &&
source.CustomProperties.TryGet("token", out string token))
{
var index = _items.IndexOf(CurrentPlayback);
guessedMimeTypeSource.CustomProperties["file"] = fileId;
guessedMimeTypeSource.CustomProperties["message"] = messageId;
guessedMimeTypeSource.CustomProperties["chat"] = chatId;
guessedMimeTypeSource.CustomProperties["token"] = token;
if (index > -1)
{
_items[index].Source = guessedMimeTypeSource;
}
_mediaPlayer.Source = guessedMimeTypeSource;
_mediaPlayer.Play();
return;
}
Clear();
MediaFailed?.Invoke(sender.PlaybackSession, args);
}
void OnMediaFailed(int handle, int channel, int data, IntPtr User)
{
if (MediaFailed != null)
{
MediaFailed.Invoke(this, new EventArgs());
}
}
private void OnMediaFailed(object sender, MediaFailedEventArgs e)
{
if (sender == CurrentPlaybackManager)
{
OnStatusChanged(sender, new StatusChangedEventArgs(MediaPlayerStatus.Failed));
}
MediaFailed?.Invoke(sender, e);
}
private void MediaSourceOnOpenOperationCompleted(MediaSource sender,
MediaSourceOpenOperationCompletedEventArgs args)
{
if (args.Error != null)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs(args.Error.ToString(), args.Error.ExtendedError));
}
}
internal void PostMediaFailedEvent(Exception ex)
{
LogEventStart(nameof(MediaFailed));
Library.GuiContext.EnqueueInvoke(() =>
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs(ex));
LogEventDone(nameof(MediaFailed));
});
}
private void MediaPlayer_Failed(object sender, RoutedEventArgs args)
{
Shutdown();
if (MediaFailed != null)
{
MediaFailed.Invoke(sender, args);
}
}
private void OnMediaFailed()
{
StringBuilder builder = new StringBuilder();
builder.AppendLine($"Description: {Player.Error.LocalizedDescription}");
builder.AppendLine($"Reason: {Player.Error.LocalizedFailureReason}");
builder.AppendLine($"Recovery Options: {Player.Error.LocalizedRecoveryOptions}");
builder.AppendLine($"Recovery Suggestion: {Player.Error.LocalizedRecoverySuggestion}");
MediaFailed?.Invoke(this, new MediaFailedEventArgs(builder.ToString(), new NSErrorException(Player.Error)));
}
private void OnMediaFailed(global::System.Exception ex = null, string message = null)
{
MediaFailed?.Invoke(this, new MediaPlayerFailedEventArgs()
{
Error = MediaPlayerError.Unknown,
ExtendedErrorCode = ex,
ErrorMessage = message ?? ex?.Message
});
PlaybackSession.PlaybackState = MediaPlaybackState.None;
}
private void _mediaPlaybackListItemFailed(MediaPlaybackList sender, MediaPlaybackItemFailedEventArgs args)
{
MusicModel model = null;
if (args.Item.Source.CustomProperties.TryGetValue("model", out object value))
{
var modelJson = value as string;
model = JsonSerializer.Deserialize <MusicModel>(modelJson);
_logger.Error($"Play music failed: \n\t{modelJson}\n\t{args.Error.ErrorCode}", args.Error.ExtendedError);
}
MediaFailed?.Invoke(model);
}
protected override void OnApplyTemplate()
{
MediaElement = (MediaElement)GetTemplateChild("MainMediaElement");
if (MediaElement != null)
{
MediaElement.CurrentStateChanged += (s, e) => CurrentStateChanged?.Invoke(this, e);
MediaElement.MediaEnded += (s, e) => MediaEnded?.Invoke(this, e);
MediaElement.MediaOpened += (s, e) => MediaOpened?.Invoke(this, e);
MediaElement.MediaFailed += (s, e) => MediaFailed?.Invoke(this, e);
MediaElement.SeekCompleted += (s, e) => SeekCompleted?.Invoke(this, e);
MediaElement.VolumeChanged += (s, e) => VolumeChanged?.Invoke(this, e);
}
base.OnApplyTemplate();
}
private async Task _play(MusicModel model)
{
try
{
var playbackItem = await _cacheMusic(model);
var playbackItemIndex = _mediaPlaybackList.Items.IndexOf(playbackItem);
_mediaPlaybackList.MoveTo((uint)playbackItemIndex);
_mediaPlayer.Play();
}
catch
{
MediaFailed?.Invoke(model);
}
}
public async Task Play(string url, MediaFileType fileType)
{
try
{
var mediaPlaybackList = new MediaPlaybackList();
var mediaSource = await CreateMediaSource(url, fileType);
var item = new MediaPlaybackItem(mediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception e)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs("Unable to start playback", e));
}
}
internal void OnServiceConnected(MediaServiceBinder serviceBinder)
{
Binder = serviceBinder;
isBound = true;
if (AlternateRemoteCallback != null)
{
GetMediaPlayerService().AlternateRemoteCallback = AlternateRemoteCallback;
}
//serviceGetMediaPlayerService().CoverReloaded += (object sender, EventArgs e) => { instance.CoverReloaded?.Invoke(sender, e); };
GetMediaPlayerService().StatusChanged += (object sender, StatusChangedEventArgs e) => { StatusChanged?.Invoke(this, e); };
GetMediaPlayerService().PlayingChanged += (sender, args) => { PlayingChanged?.Invoke(this, args); };
GetMediaPlayerService().BufferingChanged += (sender, args) => { BufferingChanged?.Invoke(this, args); };
GetMediaPlayerService().MediaFinished += (sender, args) => { MediaFinished?.Invoke(this, args); };
GetMediaPlayerService().MediaFileFailed += (sender, args) => { MediaFileFailed?.Invoke(this, args); };
GetMediaPlayerService().MediaFailed += (sender, args) => { MediaFailed?.Invoke(this, args); };
GetMediaPlayerService().SetMediaSession(_sessionManager);
}
private async void BackgroundMediaPlayer_MessageReceivedFromBackground(object sender, MediaPlayerDataReceivedEventArgs e)
{
try
{
foreach (string key in e.Data.Keys)
{
switch (key)
{
case BackgroundAudioConstants.BackgroundTaskStarted:
//Wait for Background Task to be initialized before starting playback
Debug.WriteLine("Background Task started");
if (PlayerInstanceReady.Task?.Status != TaskStatus.RanToCompletion)
{
PlayerInstanceReady.SetResult(true);
}
break;
case BackgroundAudioConstants.BackgroundTaskCancelled:
await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
Locator.MediaPlaybackViewModel.IsPlaying = false;
});
break;
case BackgroundAudioConstants.MFFailed:
LogHelper.Log("VLC process is aware MF Background Media Player failed to open the file : " + e.Data[key]);
await Locator.MediaPlaybackViewModel.SetMedia(Locator.MusicPlayerVM.CurrentTrack, true);
MediaFailed?.Invoke(this, new EventArgs());
break;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
public async Task Play(IMediaFile mediaFile = null)
{
if (VideoViewCanvas == null)
{
await Task.Delay(100);
Init();
}
if (mediaFile != null)
{
CurrentFile = mediaFile;
currentUri = Android.Net.Uri.Parse(mediaFile.Url);
}
if (Status == MediaPlayerStatus.Paused)
{
Status = MediaPlayerStatus.Playing;
//We are simply paused so just continue
VideoViewCanvas.Resume();
return;
}
try
{
Status = MediaPlayerStatus.Buffering;
VideoViewCanvas.SetVideoURI(currentUri);
VideoViewCanvas.Start();
Status = MediaPlayerStatus.Playing;
}
catch (Exception ex)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs(ex.Message, ex));
Status = MediaPlayerStatus.Stopped;
}
}
public VideoPlayerImplementation(IVolumeManager volumeManager)
{
_volumeManager = volumeManager;
_player = new MediaPlayer();
_playProgressTimer = new Timer(state =>
{
if (_player.PlaybackSession.PlaybackState == MediaPlaybackState.Playing)
{
var progress = _player.PlaybackSession.Position.TotalSeconds /
_player.PlaybackSession.NaturalDuration.TotalSeconds;
if (double.IsInfinity(progress))
{
progress = 0;
}
PlayingChanged?.Invoke(this, new PlayingChangedEventArgs(progress, _player.PlaybackSession.Position, _player.PlaybackSession.NaturalDuration));
}
}, null, 0, int.MaxValue);
_player.MediaFailed += (sender, args) =>
{
_status = MediaPlayerStatus.Failed;
_playProgressTimer.Change(0, int.MaxValue);
MediaFailed?.Invoke(this, new MediaFailedEventArgs(args.ErrorMessage, args.ExtendedErrorCode));
};
_player.PlaybackSession.PlaybackStateChanged += (sender, args) =>
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Opening:
Status = MediaPlayerStatus.Loading;
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Buffering:
Status = MediaPlayerStatus.Buffering;
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Playing:
if ((sender.PlaybackRate <= 0) && (sender.Position == TimeSpan.Zero))
{
Status = MediaPlayerStatus.Stopped;
}
else
{
Status = MediaPlayerStatus.Playing;
_playProgressTimer.Change(0, 50);
}
break;
case MediaPlaybackState.Paused:
Status = MediaPlayerStatus.Paused;
_playProgressTimer.Change(0, int.MaxValue);
break;
default:
throw new ArgumentOutOfRangeException();
}
};
_player.MediaEnded += (sender, args) => { MediaFinished?.Invoke(this, new MediaFinishedEventArgs(_currentMediaFile)); };
_player.PlaybackSession.BufferingProgressChanged += (sender, args) =>
{
var bufferedTime =
TimeSpan.FromSeconds(_player.PlaybackSession.BufferingProgress *
_player.PlaybackSession.NaturalDuration.TotalSeconds);
BufferingChanged?.Invoke(this,
new BufferingChangedEventArgs(_player.PlaybackSession.BufferingProgress, bufferedTime));
};
_player.PlaybackSession.SeekCompleted += (sender, args) => { };
_player.MediaOpened += (sender, args) => { _loadMediaTaskCompletionSource.SetResult(true); };
_volumeManager.CurrentVolume = (float)_player.Volume;
_volumeManager.Mute = _player.IsMuted;
_volumeManager.VolumeChanged += VolumeManagerOnVolumeChanged;
}
private void MediaElement_MediaFailed(object sender, ExceptionRoutedEventArgs e)
{
MediaFailed.IfNotNull(i => i(this, e.ErrorException));
}
public AudioPlayerImplementation()
{
_player = new MediaPlayer();
_playProgressTimer = new Timer(state =>
{
if (_player.PlaybackSession.PlaybackState == MediaPlaybackState.Playing)
{
var progress = _player.PlaybackSession.Position.TotalSeconds /
_player.PlaybackSession.NaturalDuration.TotalSeconds;
if (double.IsNaN(progress))
{
progress = 0;
}
PlayingChanged?.Invoke(this, new PlayingChangedEventArgs(progress, _player.PlaybackSession.Position, _player.PlaybackSession.NaturalDuration));
}
}, null, 0, int.MaxValue);
_player.MediaFailed += (sender, args) =>
{
_status = MediaPlayerStatus.Failed;
_playProgressTimer.Change(0, int.MaxValue);
MediaFailed?.Invoke(this, new MediaFailedEventArgs(args.ErrorMessage, args.ExtendedErrorCode));
};
_player.PlaybackSession.PlaybackStateChanged += (sender, args) =>
{
switch (sender.PlaybackState)
{
case MediaPlaybackState.None:
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Opening:
Status = MediaPlayerStatus.Loading;
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Buffering:
Status = MediaPlayerStatus.Buffering;
_playProgressTimer.Change(0, int.MaxValue);
break;
case MediaPlaybackState.Playing:
if (sender.PlaybackRate <= 0 && sender.Position == TimeSpan.Zero)
{
Status = MediaPlayerStatus.Stopped;
}
else
{
Status = MediaPlayerStatus.Playing;
_playProgressTimer.Change(0, 50);
}
break;
case MediaPlaybackState.Paused:
Status = MediaPlayerStatus.Paused;
_playProgressTimer.Change(0, int.MaxValue);
break;
default:
throw new ArgumentOutOfRangeException();
}
};
_player.MediaEnded += (sender, args) => { MediaFinished?.Invoke(this, new MediaFinishedEventArgs(_currentMediaFile)); };
_player.PlaybackSession.BufferingProgressChanged += (sender, args) =>
{
var bufferedTime =
TimeSpan.FromSeconds(_player.PlaybackSession.BufferingProgress *
_player.PlaybackSession.NaturalDuration.TotalSeconds);
BufferingChanged?.Invoke(this,
new BufferingChangedEventArgs(_player.PlaybackSession.BufferingProgress, bufferedTime));
};
_player.PlaybackSession.SeekCompleted += (sender, args) => { };
}
private void HandleMediaFailed(object?sender, ExceptionRoutedEventArgs?e)
{
MediaFailed?.Invoke(sender, new OnlyMMediaFailedEventArgs {
Error = e?.ErrorException
});
}
private void OnMediaFailed(MediaPlayer sender, MediaPlayerFailedEventArgs args)
{
Clear();
MediaFailed?.Invoke(sender.PlaybackSession, args);
}
private void OnMediaFailed()
{
var error = CurrentItem.Error;
MediaFailed?.Invoke(this, new MediaFailedEventArgs(error.LocalizedDescription, new NSErrorException(error)));
}
protected void RaiseMediaFailed(Exception error)
{
MediaFailed?.Invoke(error);
}
private void HandleMediaFailed(object sender, ExceptionRoutedEventArgs e)
{
MediaFailed?.Invoke(sender, e);
}
private void Player_MediaFailed(object player, CustomEventArgs <Exception> args)
{
MediaFailed.IfNotNull(i => i(this, new ScriptEventArgs <string>(args.Value.ToString())));
}
protected virtual void OnMediaFailed(MediaFailedEventArgs e)
{
MediaFailed?.Invoke(this, e);
}
void em_OnEncounteredError()
{
Debug.WriteLine("VLCService: An error occurred ");
MediaFailed?.Invoke(this, new EventArgs());
}
private void OnMediaFailed(MediaPlayer sender, MediaPlayerFailedEventArgs args)
{
Clear();
MediaFailed?.Invoke(this, args);
}
void Instance_MediaFailed(object sender, ExceptionRoutedEventArgs e)
{
MediaFailed?.Invoke(this, new EventArgs());
}
