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;
}
}
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()
{
await RaiseMediaFileFailedEventOnException(async() =>
{
MediaQueue.SetPreviousAsCurrent();
await PlayCurrent();
});
}
/// <summary>
/// Adds all MediaFiles to the Queue and starts playing the first item
/// </summary>
/// <param name="mediaFiles"></param>
/// <returns></returns>
public async Task Play(IEnumerable <IMediaFile> mediaFiles)
{
MediaQueue.Clear();
MediaQueue.AddRange(mediaFiles);
await PlayNext();
MediaNotificationManager?.StartNotification(CurrentMediaFile);
}
public void Initialization()
{
var queue = new MediaQueue();
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(null, queue.Current);
Assert.AreEqual(-1, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
}
/// <summary>
/// Adds all MediaFiles to the Queue and starts playing the first item
/// </summary>
/// <param name="mediaFiles"></param>
/// <returns></returns>
public async Task Play(IEnumerable <IMediaFile> mediaFiles)
{
MediaQueue.Clear();
MediaQueue.AddRange(mediaFiles);
// Play from index 0
MediaQueue.SetIndexAsCurrent(0);
await PlayCurrent();
MediaNotificationManager?.StartNotification(CurrentMediaFile);
}
private async Task ExtractMediaInformation(IMediaFile mediaFile)
{
var index = MediaQueue.IndexOf(mediaFile);
await MediaExtractor.ExtractMediaInfo(mediaFile);
if (index >= 0)
{
MediaQueue[index] = mediaFile;
}
OnMediaFileChanged(CurrentPlaybackManager, new MediaFileChangedEventArgs(mediaFile));
}
/// <summary>
/// Adds all MediaFiles to the Queue and starts playing the first item
/// </summary>
/// <param name="mediaFiles"></param>
/// <returns></returns>
public async Task Play(IEnumerable <IMediaFile> mediaFiles)
{
var enumerable = mediaFiles as IList <IMediaFile> ?? mediaFiles.ToList();
MediaQueue.Clear();
MediaQueue.AddRange(enumerable);
await Task.WhenAll(
PlayNext(),
GetMediaInformation(enumerable),
Task.Run(() => MediaNotificationManager?.StartNotification(MediaQueue.Current)));
}
public void Basic()
{
var queue = new MediaQueue();
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
var tracks = new[]
{
new MediaFile(),
new MediaFile(),
};
queue.Add(tracks[0]);
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(tracks[0], queue.Current);
Assert.AreEqual(0, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
Assert.AreEqual(3, propertyChangedEvents.Count);
Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems.Count == 1 && e.OldItems == null).Count());
Assert.AreEqual(1, collectionChangedEvents.Count);
queue.Add(tracks[1]);
Assert.AreEqual(2, queue.Count);
Assert.AreEqual(tracks[0], queue.Current);
Assert.AreEqual(0, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
Assert.AreEqual(2, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
Assert.AreEqual(4, propertyChangedEvents.Count);
Assert.AreEqual(2, collectionChangedEvents.Where(e => e.NewItems.Count == 1 && e.OldItems == null).Count());
Assert.AreEqual(2, collectionChangedEvents.Count);
}
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 Play(IMediaFile mediaFile = null)
{
if (mediaFile == null)
{
if (Status == MediaPlayerStatus.Paused)
{
await Resume();
return;
}
mediaFile = CurrentMediaFile;
}
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);
await RaiseMediaFileFailedEventOnException(async() =>
{
await PlayCurrent();
});
MediaNotificationManager?.StartNotification(mediaFile);
}
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);
}
}
private async Task GetMediaInformation(IEnumerable <IMediaFile> mediaFiles)
{
foreach (var mediaFile in mediaFiles)
{
try
{
var index = MediaQueue.IndexOf(mediaFile);
var info = await MediaExtractor.ExtractMediaInfo(mediaFile);
if (index >= 0)
{
MediaQueue[index] = info;
}
OnMediaFileChanged(CurrentPlaybackManager, new MediaFileChangedEventArgs(info));
}
catch (Exception e)
{
OnMediaFileFailed(this, new MediaFileFailedEventArgs(e, mediaFile));
}
}
}
/// <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));
}
}
public async Task PlayByPosition(int index)
{
MediaQueue.SetIndexAsCurrent(index);
await Play(CurrentMediaFile);
}
public void ShuffleTwice_WhenRandomNumberGeneratorWorks_OrderIsDifferent()
{
var arr = new[]
{
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile()
};
Console.WriteLine("Original: {0}", string.Join(",", arr.Select(x => x.Id)));
var queue1 = new MediaQueue();
queue1.AddRange(arr);
var queue2 = new MediaQueue();
queue2.AddRange(arr);
// Randomize in quick succession to prove that the result is not the same
// Using Random() here would create two equal lists, hence the use of PCLCrypto.
queue1.ToggleShuffle();
queue2.ToggleShuffle();
Console.WriteLine("Queue1: {0}", string.Join(",", queue1.Cast<MediaFile>().Select(x => x.Id)));
Console.WriteLine("Queue2: {0}", string.Join(",", queue2.Cast<MediaFile>().Select(x => x.Id)));
CollectionAssert.AllItemsAreUnique(queue1.Cast<MediaFile>().Select(x => x.Id));
CollectionAssert.AllItemsAreUnique(queue2.Cast<MediaFile>().Select(x => x.Id));
CollectionAssert.AreNotEqual(queue1.Cast<MediaFile>(), queue2.Cast<MediaFile>());
Assert.AreEqual(arr[queue1.Index].Id, queue1.Cast<MediaFile>().ElementAt(queue1.Index).Id, "The current item has been moved");
Assert.AreEqual(arr[queue2.Index].Id, queue2.Cast<MediaFile>().ElementAt(queue2.Index).Id, "The current item has been moved");
}
public void WhenAddingItemsWhileShuffled_OrderIsSameAsBeforeButWithExtraItem()
{
var arr = new[]
{
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile()
};
Console.WriteLine("Original: {0}", string.Join(",", arr.Select(x => x.Id)));
var queue = new MediaQueue();
Console.WriteLine("Current Index: {0}", queue.Index);
queue.AddRange(arr);
queue.ToggleShuffle();
queue.Add(new MediaFile());
Console.WriteLine("Shuffled: {0}", string.Join(",", queue.Cast<MediaFile>().Select(x => x.Id)));
queue.ToggleShuffle();
Console.WriteLine("Unshuffled: {0}", string.Join(",", queue.Cast<MediaFile>().Select(x => x.Id)));
CollectionAssert.AllItemsAreUnique(queue.Cast<MediaFile>().Select(x => x.Id));
Assert.AreEqual(arr[0].Id, queue.Cast<MediaFile>().ElementAt(0).Id);
Assert.AreEqual(arr[1].Id, queue.Cast<MediaFile>().ElementAt(1).Id);
Assert.AreEqual(arr[2].Id, queue.Cast<MediaFile>().ElementAt(2).Id);
Assert.AreEqual(arr[3].Id, queue.Cast<MediaFile>().ElementAt(3).Id);
Assert.AreEqual(arr[4].Id, queue.Cast<MediaFile>().ElementAt(4).Id);
Assert.AreEqual(arr[5].Id, queue.Cast<MediaFile>().ElementAt(5).Id);
Assert.AreEqual(arr[6].Id, queue.Cast<MediaFile>().ElementAt(6).Id);
Assert.AreEqual(arr[7].Id, queue.Cast<MediaFile>().ElementAt(7).Id);
Assert.AreEqual(arr[8].Id, queue.Cast<MediaFile>().ElementAt(8).Id);
Assert.AreEqual(arr[9].Id, queue.Cast<MediaFile>().ElementAt(9).Id);
Assert.AreEqual(arr[10].Id, queue.Cast<MediaFile>().ElementAt(10).Id);
Assert.AreEqual(arr.Length + 1, queue.Count, "The array length is different");
}
public void ShuffledAndRepeated()
{
var queue = new MediaQueue();
var tracks = new[]
{
new MediaFile(),
new MediaFile(),
};
queue.AddRange(tracks);
queue.ToggleShuffle();
queue.Repeat = RepeatType.RepeatOne;
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
queue.Clear();
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(null, queue.Current);
Assert.AreEqual(-1, queue.Index);
Assert.AreEqual(RepeatType.RepeatOne, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Shuffle").Count());
Assert.AreEqual(4, propertyChangedEvents.Count);
Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems == null && e.OldItems == null).Count());
Assert.AreEqual(1, collectionChangedEvents.Count);
}
public void Insert_OutOfRange()
{
var queue = new MediaQueue();
var tracks = new[]
{
new MediaFile(),
};
queue.AddRange(tracks);
queue.SetIndexAsCurrent(0);
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
queue.Insert(2, new MediaFile());
});
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(tracks[0], queue.Current);
Assert.AreEqual(0, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(0, propertyChangedEvents.Count);
Assert.AreEqual(0, collectionChangedEvents.Count);
}
public void Insert_OutOfRange_Empty()
{
var queue = new MediaQueue();
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
var newMediaFile = new MediaFile();
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
queue.Insert(1, newMediaFile);
});
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(null, queue.Current);
Assert.AreEqual(-1, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(0, propertyChangedEvents.Count);
Assert.AreEqual(0, collectionChangedEvents.Count);
}
public void Insert_Empty()
{
var queue = new MediaQueue();
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
var newMediaFile = new MediaFile();
queue.Insert(0, newMediaFile);
Assert.AreEqual(1, queue.Count);
Assert.AreEqual(newMediaFile, queue.Current);
Assert.AreEqual(0, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
Assert.AreEqual(3, propertyChangedEvents.Count);
Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems?.Count == 1 && e.OldItems == null).Count());
Assert.AreEqual(1, collectionChangedEvents.Count);
}
public void SetNotCurrent()
{
var queue = new MediaQueue();
var tracks = new[]
{
new MediaFile(),
new MediaFile(),
new MediaFile(),
};
queue.AddRange(tracks);
queue.SetIndexAsCurrent(1);
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
queue[0] = new MediaFile();
Assert.AreEqual(3, queue.Count);
Assert.AreEqual(tracks[1], queue.Current);
Assert.AreEqual(1, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(0, propertyChangedEvents.Count);
Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems?.Count == 1 && e.OldItems?.Count == 1).Count());
Assert.AreEqual(1, collectionChangedEvents.Count);
}
public void Remove_CurrentOnlyAndLastItem()
{
var queue = new MediaQueue();
var tracks = new[]
{
new MediaFile(),
};
queue.AddRange(tracks);
queue.SetIndexAsCurrent(0);
IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();
queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);
queue.Remove(tracks[0]);
Assert.AreEqual(0, queue.Count);
Assert.AreEqual(null, queue.Current);
Assert.AreEqual(-1, queue.Index);
Assert.AreEqual(RepeatType.None, queue.Repeat);
Assert.AreEqual(false, queue.Shuffle);
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
Assert.AreEqual(3, propertyChangedEvents.Count);
Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems == null && e.OldItems?.Count == 1).Count());
Assert.AreEqual(1, collectionChangedEvents.Count);
}
public void WhenUnshufflingWorks_OrderIsSameAsBefore()
{
var arr = new[]
{
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile(),
new MediaFile()
};
Console.WriteLine("Original: {0}", string.Join(",", arr.Select(x => x.Id)));
var queue = new MediaQueue();
Console.WriteLine("Current Index: {0}", queue.Index);
queue.AddRange(arr);
queue.ToggleShuffle();
Console.WriteLine("Shuffled: {0}", string.Join(",", queue.Cast<MediaFile>().Select(x => x.Id)));
queue.ToggleShuffle();
Console.WriteLine("Unshuffled: {0}", string.Join(",", queue.Cast<MediaFile>().Select(x => x.Id)));
CollectionAssert.AllItemsAreUnique(queue.Cast<MediaFile>().Select(x => x.Id));
CollectionAssert.AreEqual(queue.Cast<MediaFile>().Select(x => x.Id), arr.Cast<MediaFile>().Select(x => x.Id));
Assert.AreEqual(arr[queue.Index].Id, queue.Cast<MediaFile>().ElementAt(queue.Index).Id, "The current item has been moved");
Assert.AreEqual(arr.Length, queue.Count, "The array length is different");
}
