public async Task PlayNext()
{
try
{
if (MediaQueue.HasNext())
{
//await CurrentPlaybackManager.Pause();
MediaQueue.SetNextAsCurrent();
var beforePlayTask = _onBeforePlay?.Invoke(_currentMediaFile);
if (beforePlayTask != null)
{
await beforePlayTask;
}
await Task.WhenAll(
CurrentPlaybackManager.Play(_currentMediaFile),
GetMediaInformation(new[] { _currentMediaFile }));
}
else
{
await CurrentPlaybackManager.Pause();
MediaQueue.SetIndexAsCurrent(0);
OnMediaFileChanged(this, new MediaFileChangedEventArgs(MediaQueue.Current));
}
}
catch (Exception ex)
{
OnMediaFileFailed(CurrentPlaybackManager, new MediaFileFailedEventArgs(ex, _currentMediaFile));
throw;
}
}
public async Task PlayNext()
{
await RaiseMediaFileFailedEventOnException(async() =>
{
if (MediaQueue.HasNext())
{
MediaQueue.SetNextAsCurrent();
await PlayCurrent();
}
else
{
MediaQueue.SetIndexAsCurrent(0);
await PrepareCurrentAndThen(async() =>
{
await CurrentPlaybackManager.Play();
await CurrentPlaybackManager.Pause();
await Seek(TimeSpan.Zero);
});
OnMediaFileChanged(this, new MediaFileChangedEventArgs(CurrentMediaFile));
}
});
}
public async Task PlayPrevious()
{
try
{
if (!MediaQueue.HasPrevious() || (Position > TimeSpan.FromSeconds(3)))
{
await CurrentPlaybackManager.Seek(TimeSpan.Zero);
}
else
{
// await CurrentPlaybackManager.Pause();
MediaQueue.SetPreviousAsCurrent();
var beforePlayTask = _onBeforePlay?.Invoke(_currentMediaFile);
if (beforePlayTask != null)
{
await beforePlayTask;
}
await
Task.WhenAll(
CurrentPlaybackManager.Play(_currentMediaFile),
GetMediaInformation(new[] { _currentMediaFile }));
}
}
catch (Exception ex)
{
OnMediaFileFailed(CurrentPlaybackManager, new MediaFileFailedEventArgs(ex, _currentMediaFile));
throw;
}
}
private async Task Resume()
{
if (CurrentPlaybackManager == null)
{
return;
}
await CurrentPlaybackManager.Play(CurrentMediaFile);
}
public async Task Seek(TimeSpan position)
{
if (CurrentPlaybackManager == null)
{
return;
}
await CurrentPlaybackManager.Seek(position);
MediaNotificationManager?.UpdateNotifications(CurrentMediaFile, Status);
}
public async Task Stop()
{
if (CurrentPlaybackManager == null)
{
return;
}
await CurrentPlaybackManager.Stop();
MediaNotificationManager?.StopNotifications();
}
public async Task PlayPrevious()
{
// Start current track from beginning if it's the first track or the track has played more than 3sec and you hit "playPrevious".
if (!MediaQueue.HasPrevious() || (Position > TimeSpan.FromSeconds(3)))
{
await CurrentPlaybackManager.Seek(TimeSpan.Zero);
}
else
{
//TODO: Maybe pause here instead of stop
await CurrentPlaybackManager.Stop();
MediaQueue.SetPreviousAsCurrent();
await Task.WhenAll(
CurrentPlaybackManager.Play(_currentMediaFile),
GetMediaInformation(new[] { _currentMediaFile }));
}
}
public async Task PlayNext()
{
if (MediaQueue.HasNext())
{
await CurrentPlaybackManager.Stop();
MediaQueue.SetNextAsCurrent();
await Task.WhenAll(
CurrentPlaybackManager.Play(_currentMediaFile),
GetMediaInformation(new[] { _currentMediaFile }));
}
else
{
// If you don't have a next song in the queue, stop and show the meta-data of the first song.
//TODO: Shouldn't we Pause here instead of stop? Stop should shut down everything
await CurrentPlaybackManager.Stop();
MediaQueue.SetIndexAsCurrent(0);
}
}
public async Task PlayPause()
{
switch (Status)
{
case MediaPlayerStatus.Paused:
await CurrentPlaybackManager.Play(_currentMediaFile);
break;
case MediaPlayerStatus.Stopped:
await Play(_currentMediaFile);
break;
default:
await CurrentPlaybackManager.Pause();
break;
}
}
/// <summary>
/// Adds MediaFile to the Queue and starts playing
/// </summary>
/// <param name="mediaFile"></param>
/// <returns></returns>
public async Task Play(IMediaFile mediaFile)
{
if (_currentPlaybackManager != null && Status == MediaPlayerStatus.Failed)
{
await PlayNext();
return;
}
if (mediaFile == null)
{
await Play(MediaQueue);
return;
}
if (!MediaQueue.Contains(mediaFile))
{
MediaQueue.Add(mediaFile);
}
MediaQueue.SetTrackAsCurrent(mediaFile);
try
{
var beforePlayTask = _onBeforePlay?.Invoke(_currentMediaFile);
if (beforePlayTask != null)
{
await beforePlayTask;
}
await CurrentPlaybackManager.Play(mediaFile);
await GetMediaInformation(new[] { mediaFile });
MediaNotificationManager?.StartNotification(mediaFile);
}
catch (Exception ex)
{
OnMediaFileFailed(this, new MediaFileFailedEventArgs(ex, mediaFile));
}
}
private Task PlayCurrent()
{
return(PrepareCurrentAndThen(() => CurrentPlaybackManager.Play(CurrentMediaFile)));
}
public async Task Seek(TimeSpan position)
{
await CurrentPlaybackManager.Seek(position);
}
public async Task Stop()
{
await CurrentPlaybackManager.Stop();
MediaNotificationManager?.StopNotifications();
}
public async Task Pause()
{
await CurrentPlaybackManager.Pause();
}
public async Task PlayByPosition(int index)
{
var item = MediaQueue[index];
await CurrentPlaybackManager.Play(item);
}
