// Play list of songs from playlist file.
private async void Play_From_Playlist(string name)
{
var fileToPlay = fileList.Where(f => f.Name == name).FirstOrDefault();
if (fileToPlay != null)
{
queue.Clear();
Windows.Media.Playlists.Playlist playlist = await Windows.Media.Playlists.Playlist.LoadAsync(fileToPlay);
MediaPlaybackList mediaPlaybackList = new MediaPlaybackList();
foreach (var f in playlist.Files)
{
var af = songFileList.Where(sf => sf.Name == f.Name).FirstOrDefault();
queue.Add(af);
mediaPlaybackList.Items.Add(new MediaPlaybackItem(MediaSource.CreateFromStorageFile(f)));
}
if (mediaPlaybackList.Items.Count != 0)
{
mediaElement.Source = mediaPlaybackList;
mediaPlaybackList.CurrentItemChanged += new TypedEventHandler <MediaPlaybackList, CurrentMediaPlaybackItemChangedEventArgs>(Track_Changes);
mediaElement.MediaPlayer.Play();
currentPlaying = -1;
}
}
}
/// <summary>
/// Raised when playlist changes to a new track
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
// Get the new item
var item = args.NewItem;
Debug.WriteLine("PlaybackList_CurrentItemChanged: " + (item == null ? "null" : GetTrackId(item).ToString()));
// Update the system view
UpdateUVCOnNewTrack(item);
// Get the current track
Uri currentTrackId = null;
if (item != null)
{
currentTrackId = item.Source.CustomProperties[TrackIdKey] as Uri;
}
// Notify foreground of change or persist for later
if (foregroundAppState == AppState.Active)
{
MessageService.SendMessageToForeground(new TrackChangedMessage(currentTrackId));
}
else
{
ApplicationSettingsHelper.SaveSettingsValue(TrackIdKey, currentTrackId == null ? null : currentTrackId.ToString());
}
}
/// <summary>
/// Create a playback list from the list of songs received from the foreground app.
/// </summary>
/// <param name="songs"></param>
void CreatePlaybackList(IEnumerable <SongModel> songs)
{
// Make a new list and enable looping
playbackList = new MediaPlaybackList();
playbackList.AutoRepeatEnabled = true;
// Add playback items to the list
foreach (var song in songs)
{
var source = MediaSource.CreateFromUri(song.MediaUri);
source.CustomProperties[TrackIdKey] = song.MediaUri;
source.CustomProperties[TitleKey] = song.Title;
source.CustomProperties[AlbumArtKey] = song.AlbumArtUri;
playbackList.Items.Add(new MediaPlaybackItem(source));
}
// Don't auto start
BackgroundMediaPlayer.Current.AutoPlay = false;
// Assign the list to the player
BackgroundMediaPlayer.Current.Source = playbackList;
// Add handler for future playlist item changes
playbackList.CurrentItemChanged += PlaybackList_CurrentItemChanged;
}
/// <summary>
/// Deletes track from playback list
/// </summary>
/// <param name="stream_url"></param>
void DeleteTrackFromPlaybackList(string stream_url)
{
Debug.WriteLine($"BackgroundAudioTask.DeleteTrackFromPlaybackList: Deleting track {stream_url} from playback list.");
//MessageService.SendMessageToForeground(this, new PlaybackListEmptyMessage());
var mediaPlaybackItem = playbackList.Items.Where(mpi => mpi.Source.CustomProperties[TrackIdKey].ToString() == stream_url).FirstOrDefault();
if (mediaPlaybackItem != null)
{
playbackList.Items.Remove(mediaPlaybackItem);
if (playbackList.Items.Count == 0)
{
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
BackgroundMediaPlayer.Current.Pause();
// Inform foreground that playback list is empty
MessageService.SendMessageToForeground(this, new PlaybackListEmptyMessage());
}
}
else
{
throw new Exception($"There is no track in current playback list with stream_url {stream_url}");
}
}
private async void PlayList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var playbackItem = args.NewItem;
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => this.CurrentMediaPlaybackItem = playbackItem);
if (playbackItem != null)
{
await SetCurrentSong(playbackItem.GetDisplayProperties());
}
else
{
await SetCurrentSong(null);
}
async Task SetCurrentSong(MediaItemDisplayProperties displayPropertys)
{
if (this.Dispatcher.HasThreadAccess)
{
if (displayPropertys != null)
{
this.CurrentSong = await SongInformation.Create(displayPropertys.MusicProperties.AlbumTitle, string.IsNullOrWhiteSpace(displayPropertys.MusicProperties.Artist)?displayPropertys.MusicProperties.AlbumArtist : displayPropertys.MusicProperties.Artist, displayPropertys.MusicProperties.Title, displayPropertys.Thumbnail);
}
else
{
this.CurrentSong = null;
}
}
else
{
await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => await SetCurrentSong(displayPropertys));
}
}
}
/// <summary>
/// Handles background task cancellation. Task cancellation happens due to:
/// 1. Another Media app comes into foreground and starts playing music
/// 2. Resource pressure. Your task is consuming more CPU and memory than allowed.
/// In either case, save state so that if foreground app resumes it can know where to start.
/// </summary>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
// You get some time here to save your state before process and resources are reclaimed
Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested...");
try
{
// immediately set not running
backgroundTaskStarted.Reset();
// save state
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
// unsubscribe from list changes
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
// unsubscribe event handlers
BackgroundMediaPlayer.MessageReceivedFromForeground -= BackgroundMediaPlayer_MessageReceivedFromForeground;
smtc.ButtonPressed -= smtc_ButtonPressed;
smtc.PropertyChanged -= smtc_PropertyChanged;
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
private void Enqueue(TLMessage message, bool play)
{
if (message.Media is TLMessageMediaDocument documentMedia && documentMedia.Document is TLDocument document)
{
var fileName = document.GetFileName();
if (File.Exists(FileUtils.GetTempFileName(fileName)))
{
var item = new MediaPlaybackItem(MediaSource.CreateFromUri(FileUtils.GetTempFileUri(fileName)));
_mapping[item] = message;
_inverse[message] = item;
if (play)
{
_playlist = new MediaPlaybackList();
_playlist.CurrentItemChanged += OnCurrentItemChanged;
_playlist.Items.Add(item);
_playlist.Items.Add(_silence);
_mediaPlayer.Source = _playlist;
_mediaPlayer.Play();
}
else
{
_playlist.Items.Insert(_playlist.Items.Count - 1, item);
}
}
else
{
document.DownloadAsync(_downloadManager, x => Enqueue(message, play));
}
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (MusicPlayer == null)
{
// Setup playlist and media player
MusicPlaylist = new MediaPlaybackList
{
AutoRepeatEnabled = true,
ShuffleEnabled = ViewModel.ShuffleOn,
MaxPlayedItemsToKeepOpen = 3
};
MusicPlayer = new MediaPlayer
{
Volume = ViewModel.MusicPlayerVolume,
IsLoopingEnabled = ViewModel.RepeatOn,
AutoPlay = ViewModel.AutoPlayOn,
Source = MusicPlaylist,
};
musicPlayerElement.SetMediaPlayer(MusicPlayer);
}
ViewModel.PropertyChanged += ViewModel_PropertyChanged;
MusicPlayer.VolumeChanged += MusicPlayer_VolumeChanged;
MusicPlayer.PlaybackSession.PlaybackStateChanged += MusicPlaybackSession_PlaybackStateChanged;
MusicPlaylist.CurrentItemChanged += MusicPlaybackList_CurrentItemChanged;
ViewModel.SetUpVM(this);
}
public MediaPlayerManager(IMessenger messenger)
{
_messenger = messenger;
_mediaPlayer = new MediaPlayer();
_mediaPlaybackList = new MediaPlaybackList();
_mediaPlayer.CommandManager.IsEnabled = true;
_messenger.Register <GenericMessage <Cast> >(this, Message.REQUEST_MEDIAPLAYER_PLAY_SONG, PlayRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_PAUSE_SONG, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_RESUME_SONG, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_PREVIOUS_SONG, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_NEXT_SONG, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_ENABLE_LOOPING, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_DISABLE_LOOPING, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_GET_ACCESS_TO_PLAYBACK_TIMELINE, NotificationRequestAction);
_messenger.Register <NotificationMessage>(this, Message.REQUEST_MEDIAPLAYER_RELEASE_ACCESS_TO_PLAYBACK_TIMELINE, NotificationRequestAction);
_messenger.Register <GenericMessage <double> >(this, Message.REQUEST_MEDIAPLAYER_UPDATE_VOLUME, UpdateVolumeRequestAction);
_messenger.Register <GenericMessage <double> >(this, Message.REQUEST_MEDIAPLAYER_UPDATE_PLAYBACK_TIMELINE_POSITION, UpdatePlaybackTimelinePositionAction);
_messenger.Register <NotificationMessageWithCallback>(this, Message.IS_MEDIAPLAYER_PLAYBACK_STATE_PLAYING, CheckPlaybackPlayingState);
_mediaPlayer.MediaOpened += MediaOpened;
_mediaPlayer.MediaEnded += MediaEnded;
_mediaPlayer.MediaFailed += MediaFailed;
_mediaPlayer.BufferingStarted += BufferingStarted;
_mediaPlayer.BufferingEnded += BufferingEnded;
_mediaPlayer.SourceChanged += SourceChanged;
_mediaPlayer.PlaybackSession.PlaybackStateChanged += PlaybackStateChanged;
_mediaPlayer.PlaybackSession.PositionChanged += PositionChanged;
}
public PlayingQueue(MediaPlayer player, LibraryService libraryService)
{
this.player = player;
this.libraryService = libraryService;
player.Source = null;
player.AutoPlay = true;
queue = new MediaPlaybackList();
items = new TrackList(queue);
queue.CurrentItemChanged += (s, a) =>
{
CurrentItemChanged?.Invoke(
(Track)a.NewItem?.Source.CustomProperties["track"],
(Track)a.OldItem?.Source.CustomProperties["track"]);
};
queue.Items.VectorChanged += (sender, a) =>
{
/* If the playbacklist is empty we unset the player source */
if (sender.Count > 0)
{
if (player.Source == null)
{
player.Source = queue;
}
}
else
{
player.Source = null;
}
};
}
public async System.Threading.Tasks.Task AddMedia(ListView listView, MediaPlayerElement mediaPlayerElement)
{
var filePicker = new Windows.Storage.Pickers.FileOpenPicker();
string[] fileTypes = new string[] { ".wmv", ".mp3", ".mp4", ".wma" };
foreach (string fileType in fileTypes)
{
filePicker.FileTypeFilter.Add(fileType);
}
filePicker.SuggestedStartLocation = PickerLocationId.MusicLibrary;
MediaPlaybackList _mediaPlaybackList = new MediaPlaybackList();
var pickedFiles = await filePicker.PickMultipleFilesAsync();
foreach (var file in pickedFiles)
{
var mediaPlaybackItem = new MediaPlaybackItem(MediaSource.CreateFromStorageFile(file));
_mediaPlaybackList.Items.Add(mediaPlaybackItem);
listView.Items.Add(file.DisplayName);
}
_mediaPlaybackList.AutoRepeatEnabled = true;
mediaPlayerElement.Source = _mediaPlaybackList;
}
private async void SingerHotSongList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
uint CurrentIndex = sender.CurrentItemIndex;
if (CurrentIndex == 4294967295)
{
return;
}
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
if (MediaControl.MediaPlayer.Source == MediaPlayList.SingerHotSongList && MediaPlayList.HotSongBackup.Count > 0)
{
SearchSingleMusic music = MediaPlayList.HotSongBackup[Convert.ToInt32(CurrentIndex)];
var SongSearchResult = await NeteaseMusicAPI.GetInstance().SearchAsync <SingleMusicSearchResult>(music.MusicName, 5, 0, NeteaseMusicAPI.SearchType.Song);
foreach (var Song in SongSearchResult.Result.Songs.Where(Song => Song.Name == music.MusicName && Song.Al.Name == music.Album).Select(Song => Song))
{
var bitmap = new BitmapImage();
PicturePlaying.Source = bitmap;
bitmap.UriSource = new Uri(Song.Al.PicUrl);
break;
}
MediaItemDisplayProperties Props = args.NewItem.GetDisplayProperties();
Props.Type = Windows.Media.MediaPlaybackType.Music;
Props.MusicProperties.Title = music.MusicName;
Props.MusicProperties.Artist = music.Album;
args.NewItem.ApplyDisplayProperties(Props);
}
});
}
private void OnCurrentItemChangedAsync(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var newItem = args.NewItem;
if (newItem == null)
{
return;
}
ChangeSelectItem();
if (newItem.Source.CustomProperties["Message"] is MusicBoardParameter para)
{
AppResources.MusicIsCurrent = para;
}
if (ServiceType == MusicServiceType.MHz)
{
ActionForMHz?.Invoke();
}
CacheItems.Add(newItem);
if (CacheItems.Count <= CacheMax || CacheItems.ToList().Exists(i => i.Source.CustomProperties["SHA256"] as string == newItem.Source.CustomProperties["SHA256"] as string))
{
return;
}
CacheItems[0].Source.Reset();
CacheItems.RemoveAt(0);
}
public MediaListViewModel(ObservableCollection <LocalMusicModel> mediaList, MediaPlaybackList playbackList, CoreDispatcher dispatcher)
{
MediaList = mediaList;
PlaybackList = playbackList;
this.dispatcher = dispatcher;
// Verify consistency of the lists that were passed in
var mediaListIds = mediaList.Select(i => i.Music.Id);
var playbackListIds = playbackList.Items.Select(
i => (string)i.Source.CustomProperties.SingleOrDefault(
p => p.Key == LocalMusicModel.MediaItemIdKey).Value);
var a = mediaListIds.ToList();
var b = playbackListIds.ToList();
// Initialize the view model items
initializing = true;
foreach (var mediaItem in mediaList)
{
Add(new MediaItemViewModel(this, mediaItem));
}
initializing = false;
// The view model supports TwoWay binding so update when the playback list item changes
PlaybackList.CurrentItemChanged += PlaybackList_CurrentItemChanged;
// Start where the playback list is currently at
CurrentItemIndex = (int)PlaybackList.CurrentItemIndex;
}
private void OnCurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
if (args.NewItem == null)
{
//Execute.BeginOnUIThread(() => CurrentItem = null);
//Dispose();
//Debug.WriteLine("PlaybackService: Playback completed");
}
else if (_mapping.TryGetValue(args.NewItem, out TLMessage message))
{
Execute.BeginOnUIThread(() => CurrentItem = message);
Debug.WriteLine("PlaybackService: Playing message " + message.Id);
MarkAsRead(message);
}
else
{
Execute.BeginOnUIThread(() => CurrentItem = null);
Debug.WriteLine("PlaybackService: Current item changed, can't find related message");
}
if (_queue != null && _queue.Count > 0)
{
Enqueue(_queue.Dequeue(), false);
}
}
public void Attach(MediaPlaybackList playbackList)
{
Detach();
playbackList.SetShuffledItems(Enumerable.Repeat(playbackList.CurrentItem, playbackList.Items.Count));
playbackList.AutoRepeatEnabled = true;
playbackList.ShuffleEnabled = true;
}
public async Task Play(IMediaFile mediaFile)
{
_loadMediaTaskCompletionSource = new TaskCompletionSource <bool>();
try
{
if (_currentMediaSource != null)
{
_currentMediaSource.StateChanged -= MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted -= MediaSourceOnOpenOperationCompleted;
}
// Todo: sync this with the playback queue
var mediaPlaybackList = new MediaPlaybackList();
_currentMediaSource = await CreateMediaSource(mediaFile);
_currentMediaSource.StateChanged += MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted += MediaSourceOnOpenOperationCompleted;
var item = new MediaPlaybackItem(_currentMediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception)
{
Debug.WriteLine("Unable to open url: " + mediaFile.Url);
}
}
private async void Shuffle_Button_Click(object sender, RoutedEventArgs e)
{
var buttonTag = ((Button)sender).Tag.ToString();
if (fileList != null)
{
var fileToPlay = fileList.Where(f => f.Name == buttonTag).FirstOrDefault();
if (fileToPlay != null)
{
Playlist playlist = await Playlist.LoadAsync(fileToPlay);
MediaPlaybackList mediaPlaybackList = new MediaPlaybackList();
foreach (var item in playlist.Files)
{
mediaPlaybackList.Items.Add(new MediaPlaybackItem(MediaSource.CreateFromStorageFile(item)));
}
mediaPlaybackList.ShuffleEnabled = true;
IReadOnlyList <MediaPlaybackItem> items = mediaPlaybackList.ShuffledItems;
MediaPlaybackList newplaybacklist = new MediaPlaybackList();
foreach (var item in items)
{
newplaybacklist.Items.Add(item);
}
if (newplaybacklist.Items.Count != 0)
{
mediaElement.Source = newplaybacklist;
mediaElement.MediaPlayer.Play();
}
}
}
}
public void Dispose()
{
this.UnregisterForMediaPlaybackListEvents();
this.logView = null;
this.mediaPlaybackList = null;
}
private async void MediaPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Error.Text = args.NewItem.AudioTracks.First().Name;
});
}
/// <summary>
/// Handles background task cancellation. Task cancellation happens due to:
/// 1. Another Media app comes into foreground and starts playing music
/// 2. Resource pressure. Your task is consuming more CPU and memory than allowed.
/// In either case, save state so that if foreground app resumes it can know where to start.
/// </summary>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
try
{
backgroundTaskStarted.Reset();
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.PlaybackSession.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
if (playbackList != null)
{
playbackList.CurrentItemChanged -= OnCurrentItemChanged;
playbackList = null;
}
BackgroundMediaPlayer.MessageReceivedFromForeground -= OnMessageFromForegroundReceived;
smtc.ButtonPressed -= OnSmtcButtonPressed;
smtc.PropertyChanged -= OnSmtcPropertyChanged;
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral.Complete();
}
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
Debug.WriteLine($"{nameof(BackgroundAudioTask)} {sender.Task.TaskId} Cancel Requested...");
try
{
backgroundTaskStarted.Reset();
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, GetCurrentTrackId()?.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled);
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, foregroundAppState);
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
BackgroundMediaPlayer.MessageReceivedFromForeground -= BackgroundMediaPlayer_MessageReceivedFromForeground;
smtc.ButtonPressed -= smtc_ButtonPressed;
smtc.PropertyChanged -= smtc_PropertyChanged;
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
deferral.Complete();
Debug.WriteLine(nameof(BackgroundAudioTask) + " Cancel complete...");
}
public static async void AudioMediaPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
if (args.NewItem == null)
{
RequestSyncPlayList();
return;
}
NowPlaying = (int)HyPlayList.PlaybackList.CurrentItemIndex;
if (!MPIToIndex.ContainsKey(args.NewItem))
{
return;
}
HyPlayItem hpi = List[MPIToIndex[args.NewItem]];
AudioInfo ai = hpi.AudioInfo;
//LoadSystemPlayBar(MPIToIndex[args.NewItem]);
if (hpi.ItemType == HyPlayItemType.Netease && hpi.AudioInfo.Lyric == null)
{
PureLyricInfo lrcs = await LoadNCLyric(hpi);
ai.Lyric = lrcs.PureLyrics;
ai.TrLyric = lrcs.TrLyrics;
}
//先进行歌词转换以免被搞
Lyrics = Utils.ConvertPureLyric(ai.Lyric);
Utils.ConvertTranslation(ai.TrLyric, Lyrics);
hpi.AudioInfo = ai;
//这里为调用订阅本事件的元素
Invoke(() => OnPlayItemChange?.Invoke(hpi));
}
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;
}
}
/// <summary>
/// 同步正在播放的项目到UI界面
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
playlistView.SelectedIndex = (int)sender.CurrentItemIndex;
});
}
private async Task <IMediaPlaybackSource> CreateSource()
{
IMediaPlaybackSource source = null;
var sourceData = (MediaData.SourceDesc) this.sourceBox.SelectedItem;
if (!IsPlayList)
{
var uri = new Uri(sourceData.Source.ToString());
if (sourceData.IsAdaptive)
{
var result = await Windows.Media.Streaming.Adaptive.AdaptiveMediaSource.CreateFromUriAsync(uri);
source = Windows.Media.Core.MediaSource.CreateFromAdaptiveMediaSource(result.MediaSource);
}
else
{
source = new Windows.Media.Playback.MediaPlaybackItem(Windows.Media.Core.MediaSource.CreateFromUri(new Uri((sourceData.Source.ToString()))));
}
}
else
{
var urls = (string[])sourceData.Source;
var sources = urls.Select(url => Windows.Media.Core.MediaSource.CreateFromUri(new Uri(url)));
var items = sources.Select(s => new MediaPlaybackItem(s));
var list = new MediaPlaybackList();
list.Items.Clear();
foreach (var i in items)
{
list.Items.Add(i);
}
source = list;
}
return(source);
}
/// <summary>
/// Setup the playback service class for use.
/// </summary>
public PlaybackService()
{
// Only keep 5 items open and do not auto repeat
// as we will be loading more items once we reach the
// end of a list (or starting over if in playlist)
var mediaPlaybackList = new MediaPlaybackList
{
MaxPlayedItemsToKeepOpen = 2,
AutoRepeatEnabled = false
};
// Create the media player and disable auto play
// as we are going to use a playback list. Set the
// source to the media playback list. Auto play is true so if
// we reach the end of a playlist (or source) start from the beginning.
MediaPlayer = new MediaPlayer
{
AutoPlay = true,
Source = mediaPlaybackList
};
// Create the youtube client used to parse YouTube streams.
_youTubeClient = new YoutubeClient();
// Assign event handlers
MediaPlaybackList.CurrentItemChanged += MediaPlaybackListOnCurrentItemChanged;
MediaPlayer.CurrentStateChanged += MediaPlayerOnCurrentStateChanged;
MediaPlayer.MediaFailed += (sender, args) =>
{
Debug.WriteLine(args.ErrorMessage);
};
}
/// <summary>
/// Called when the current playing item changes
/// </summary>
private async void CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
await DispatcherHelper.ExecuteOnUIThreadAsync(async() =>
{
// Only perform the following actions if there is a new track
if (args.NewItem == null)
{
return;
}
if (Service.CurrentTrack == null)
{
return;
}
// Set the pin button text
PinButtonText = TileService.Instance.DoesTileExist("Track_" + Service.CurrentTrack.Id) ? "Unpin" : "Pin";
// Set the like button text
LikeButtonText = await SoundByteService.Instance.ExistsAsync("/me/favorites/" + Service.CurrentTrack.Id)
? "Unlike"
: "Like";
// Set the repost button text
RepostButtonText =
await SoundByteService.Instance.ExistsAsync("/e1/me/track_reposts/" + Service.CurrentTrack.Id)
? "Unpost"
: "Repost";
// Reload all the comments
CommentItems.RefreshItems();
});
}
public MediaListViewModel(MediaList mediaList, MediaPlaybackList playbackList, CoreDispatcher dispatcher)
{
MediaList = mediaList;
PlaybackList = playbackList;
this.dispatcher = dispatcher;
// Verify consistency of the lists that were passed in
var mediaListIds = mediaList.Select(i => i.ItemId);
var playbackListIds = playbackList.Items.Select(
i => (string)i.Source.CustomProperties.SingleOrDefault(
p => p.Key == MediaItem.MediaItemIdKey).Value);
if (!mediaListIds.SequenceEqual(playbackListIds))
{
throw new ArgumentException("The passed in data model and playback model did not have the same sequence of items");
}
// Initialize the view model items
initializing = true;
foreach (var mediaItem in mediaList)
{
Add(new MediaItemViewModel(this, mediaItem));
}
initializing = false;
// The view model supports TwoWay binding so update when the playback list item changes
PlaybackList.CurrentItemChanged += PlaybackList_CurrentItemChanged;
// Start where the playback list is currently at
CurrentItemIndex = (int)PlaybackList.CurrentItemIndex;
}
/// <summary>
/// This call comes in on a worker thread so requires a little extra care
/// to avoid touching the UI if it has already been disposed.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
// If the event was unsubscribed before
// this handler executed just return.
if (disposed)
{
return;
}
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// If the event was unsubscribed before
// this handler executed just return.
if (disposed)
{
return;
}
var playbackItem = args.NewItem;
if (playbackItem == null)
{
CurrentItem = null;
}
else
{
// Find the single item in this list with a playback item
// matching the one we just received the event for.
CurrentItem = this.Single(mediaItemViewModel => mediaItemViewModel.PlaybackItem == playbackItem);
}
});
}
void LocalizedSpeaker.Say(LocalizedPhrase phrase)
{
_logger.Method().Start(phrase.Text());
try
{
_mediaElement.Stop();
MediaPlaybackItem[] items = Enumerable.Range(0, Convert.ToInt32(phrase.TokensCount()))
.Select(Convert.ToUInt32)
.Select(phrase.Token)
.Select(token => _voiceFileHelper.GetFileUri(token, phrase.Language(), _settingsRepository.GuideSpeakerSex))
.Where(uri => uri != null)
.Select(MediaSource.CreateFromUri)
.Select(src => new MediaPlaybackItem(src))
.ToArray();
var playList = new MediaPlaybackList();
items.ForEach(playList.Items.Add);
_mediaElement.SetPlaybackSource(playList);
_mediaElement.Play();
_logger.Method().End();
}
catch (Exception exception)
{
_logger.Method().Exception(exception);
}
}
public void Detach()
{
if (_playbackList != null)
{
_playbackList.CurrentItemChanged -= playbackList_CurrentItemChanged;
_playbackList = null;
}
}
public void Attach(MediaPlaybackList playbackList)
{
playbackList.SetShuffledItems((from i in playbackList.Items
orderby _random.Next()
select i).ToList());
playbackList.ShuffleEnabled = true;
playbackList.AutoRepeatEnabled = true;
}
private void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Synchronize our UI with the currently-playing item.
playlistView.SelectedIndex = (int)sender.CurrentItemIndex;
});
}
public MainPageViewModel()
{
PlaybackList = new ObservableCollection<MediaPlaybackItemDataWrapper>();
MediaPlaybackList = new MediaPlaybackList();
MediaPlaybackList.AutoRepeatEnabled = true;
BuildMediaPlaybackList();
MediaPlaybackList.CurrentItemChanged += MediaPlaybackList_CurrentItemChanged;
}
private async void MediaPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
await UIDispatcher.RunAsync(CoreDispatcherPriority.High, () =>
{
var newItem = PlaybackList.Where(x => x.SourceObject == args.NewItem).FirstOrDefault();
var oldItem = PlaybackList.Where(x => x.SourceObject == args.OldItem).FirstOrDefault();
if (newItem != null)
{
newItem.State = "Playing";
PlayingItemChanged?.Invoke(null, newItem);
}
if (oldItem != null)
{
oldItem.State = string.Empty;
}
});
}
/// <summary>
/// Raised when playlist changes to a new track
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
// Get the new item
var item = args.NewItem;
Debug.WriteLine("PlaybackList_CurrentItemChanged: " + (item == null ? "null" : GetTrackId(item).ToString()));
// Update the system view
UpdateUVCOnNewTrack(item);
// Get the current track
string currentTrackId = null;
if (item != null)
currentTrackId = item.Source.CustomProperties[TrackIdKey] as string;
// Notify foreground of change or persist for later
if (foregroundAppState == AppState.Active)
MessageService.SendMessageToForeground(new TrackChangedMessage(currentTrackId));
else
ApplicationSettingsHelper.SaveSettingsValue(TrackIdKey, currentTrackId?.ToString());
}
public void Attach(MediaPlaybackList playbackList)
{
playbackList.AutoRepeatEnabled = true;
playbackList.ShuffleEnabled = false;
}
/// <summary>
/// Handles background task cancellation. Task cancellation happens due to:
/// 1. Another Media app comes into foreground and starts playing music
/// 2. Resource pressure. Your task is consuming more CPU and memory than allowed.
/// In either case, save state so that if foreground app resumes it can know where to start.
/// </summary>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
// You get some time here to save your state before process and resources are reclaimed
Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested...");
try
{
// immediately set not running
backgroundTaskStarted.Reset();
// save state
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, GetCurrentTrackId() == null ? null : GetCurrentTrackId().ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.Position, BackgroundMediaPlayer.Current.Position.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.BackgroundTaskState, BackgroundTaskState.Canceled.ToString());
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.AppState, Enum.GetName(typeof(AppState), foregroundAppState));
// unsubscribe from list changes
if (playbackList != null)
{
playbackList.CurrentItemChanged -= PlaybackList_CurrentItemChanged;
playbackList = null;
}
// unsubscribe event handlers
BackgroundMediaPlayer.MessageReceivedFromForeground -= BackgroundMediaPlayer_MessageReceivedFromForeground;
smtc.ButtonPressed -= smtc_ButtonPressed;
smtc.PropertyChanged -= smtc_PropertyChanged;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
private void MediaPlaybackListOnCurrentItemChanged(MediaPlaybackList sender,
CurrentMediaPlaybackItemChangedEventArgs args)
{
// Get the new item
var item = args.NewItem;
// Get the current track
var currentTrack = item?.Source?.Queue();
// Update the system view
_smtcWrapper.UpdateUvcOnNewTrack(currentTrack?.Track);
if (currentTrack != null)
{
Debug.WriteLine("PlaybackList_CurrentItemChanged: " + currentTrack.Id);
// Notify foreground of change or persist for later
if (ForegroundAppState == AppState.Active)
MessageHelper.SendMessageToForeground(new TrackChangedMessage(currentTrack.Id));
_settingsUtility.Write(ApplicationSettingsConstants.QueueId, currentTrack.Id);
}
}
/// <summary>
/// Create a playback list from the list of songs received from the foreground app.
/// </summary>
/// <param name="queues"></param>
public async void CreatePlaybackList(IEnumerable<QueueTrack> queues)
{
// Make a new list and enable looping
_mediaPlaybackList = new MediaPlaybackList {AutoRepeatEnabled = false};
// Add playback items to the list
foreach (var song in queues)
{
MediaSource source;
if (song.Track.Type == TrackType.Stream || song.Track.AudioLocalUri == null)
source = MediaSource.CreateFromUri(new Uri(song.Track.AudioWebUri));
else
{
source = MediaSource.CreateFromStorageFile(
await StorageHelper.GetFileFromPathAsync(song.Track.AudioLocalUri));
}
source.Queue(song);
_mediaPlaybackList.Items.Add(new MediaPlaybackItem(source));
}
// auto start
BackgroundMediaPlayer.Current.AutoPlay = true;
_playbackStartedPreviously = true;
// Assign the list to the player
BackgroundMediaPlayer.Current.Source = _mediaPlaybackList;
// Add handler for future playlist item changes
_mediaPlaybackList.CurrentItemChanged += MediaPlaybackListOnCurrentItemChanged;
}
async void IAudioController.SetPlaylist(IReadOnlyList<TrackInfo> tracks, TrackInfo nextTrack, bool autoPlay)
{
if (_stateMachine.CanFire(Triggers.SetMediaPlaybackList))
{
_stateMachine.Fire(Triggers.SetMediaPlaybackList);
var mediaPlaybackList = new MediaPlaybackList();
mediaPlaybackList.ItemOpened += MediaPlaybackList_ItemOpened;
mediaPlaybackList.ItemFailed += MediaPlaybackList_ItemFailed;
mediaPlaybackList.CurrentItemChanged += MediaPlaybackList_CurrentItemChanged;
var items = tracks.Select(o =>
{
var streamRef = new UriRandomAccessStreamReference(o.Source);
return new MediaPlaybackItem(MediaSource.CreateFromStreamReference(streamRef, "audio/mp3"));
}).ToList();
items.Sink(mediaPlaybackList.Items.Add);
mediaPlaybackList.StartingItem = items[tracks.IndexOf(nextTrack)];
_currentPlayMode?.Detach();
_currentPlayMode?.Attach(mediaPlaybackList);
_playlist = tracks;
_currentTrack = nextTrack;
_playbackItems = items;
_mediaPlaybackList = mediaPlaybackList;
_autoPlay = autoPlay;
_mediaPlayer.Source = mediaPlaybackList;
}
}
private void MediaPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
int index;
if ((index = _playbackItems?.IndexOf(args.NewItem) ?? -1) != -1)
{
var playlist = _playlist;
if (index < playlist?.Count)
{
_currentTrack = playlist[index];
Execute.BeginOnUIThread(() => _audioControllerHandler.OnCurrentTrackChanged(_currentTrack));
}
}
}
/// <summary>
/// Create a playback list from the list of songs received from the foreground app.
/// </summary>
/// <param name="songs"></param>
void CreatePlaybackList(IEnumerable<Track> songs)
{
// Make a new list and enable looping
playbackList = new MediaPlaybackList();
playbackList.AutoRepeatEnabled = true;
// Add playback items to the list
foreach (var song in songs)
{
var source = MediaSource.CreateFromUri(GetMusicFile(song.Id));
source.CustomProperties[TrackIdKey] = song.Id;
source.CustomProperties[TitleKey] = song.Title;
source.CustomProperties[ArtistKey] = song.User.Username;
source.CustomProperties[AlbumArtKey] = song.ArtworkUrl;
playbackList.Items.Add(new MediaPlaybackItem(source));
}
// Don't auto start
BackgroundMediaPlayer.Current.AutoPlay = true;
// Assign the list to the player
BackgroundMediaPlayer.Current.Source = playbackList;
// Add handler for future playlist item changes
playbackList.CurrentItemChanged += PlaybackList_CurrentItemChanged;
}
/// <summary>
/// Handles background task cancellation. Task cancellation happens due to:
/// 1. Another Media app comes into foreground and starts playing music
/// 2. Resource pressure. Your task is consuming more CPU and memory than allowed.
/// In either case, save state so that if foreground app resumes it can know where to start.
/// </summary>
private void OnCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason)
{
// You get some time here to save your state before process and resources are reclaimed
Debug.WriteLine("MyBackgroundAudioTask " + sender.Task.TaskId + " Cancel Requested...");
try
{
// immediately set not running
_backgroundTaskStarted.Reset();
// unsubscribe from list changes
if (_playbackList != null)
{
_playbackList.CurrentItemChanged -= PlaybackListCurrentItemChanged;
_playbackList = null;
}
// remove handlers for MediaPlayer
BackgroundMediaPlayer.Current.CurrentStateChanged -= MediaPlayerStateChanged;
BackgroundMediaPlayer.Current.MediaEnded -= MediaPlayerMediaEnded;
// unsubscribe event handlers
BackgroundMediaPlayer.MessageReceivedFromForeground -= MessageReceivedFromForeground;
smtc.ButtonPressed -= AudioControlButtonPressed;
smtc.PropertyChanged -= AudioControlPropertyChanged;
BackgroundMediaPlayer.Shutdown(); // shutdown media pipeline
}
catch (Exception ex)
{
telemetry.TrackException(ex, new Dictionary<string, string> { { "Scenario", "BackgroundAudioCancel" } });
}
_deferral.Complete(); // signals task completion.
Debug.WriteLine("MyBackgroundAudioTask Cancel complete...");
}
private async void SubscribedPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
if (disposed) return;
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (disposed) return;
HandlePlaybackListChanges(sender.Items);
});
}
/// <summary>
/// Raised when playlist changes to a new track
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void PlaybackListCurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
// Get the new item
var item = args.NewItem;
// Update the system view
UpdateUVCOnNewTrack(item);
// Get the current track
if (item != null && item.Source.CustomProperties.ContainsKey(QuranTrackKey))
{
var json = item.Source.CustomProperties[QuranTrackKey] as string;
MessageService.SendMessageToForeground(new TrackChangedMessage(QuranAudioTrack.FromString(json)));
}
}
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));
}
}
private void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var ignoreAwaitWarning = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var currentItem = sender.CurrentItem;
playlistView.SelectedIndex = playbackList.Items.ToList().FindIndex(i => i == currentItem);
});
}
private void MediaPlaybackList_ItemOpened(MediaPlaybackList sender, MediaPlaybackItemOpenedEventArgs args)
{
}
private void playbackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
sender.SetShuffledItems(new[] { args.NewItem });
}
/// <summary>
/// Handle item failures
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void PlaybackList_ItemFailed(MediaPlaybackList sender, MediaPlaybackItemFailedEventArgs args)
{
// Media callbacks use a worker thread so dispatch to UI as needed
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var error = string.Format("Item failed to play: {0} | 0x{1:x}",
args.Error.ErrorCode, args.Error.ExtendedError.HResult);
MainPage.Current.NotifyUser(error, NotifyType.ErrorMessage);
});
}
/// <summary>
/// Create a playback list from the list of songs received from the foreground app.
/// </summary>
/// <param name="songs"></param>
private async Task CreatePlaybackList(QuranAudioTrack newTrack)
{
BackgroundMediaPlayer.Current.Pause();
// Make a new list
if (_playbackList != null)
{
_playbackList.CurrentItemChanged -= PlaybackListCurrentItemChanged;
_playbackList.Items.Clear();
}
else
{
_playbackList = new MediaPlaybackList();
}
// Initialize FileUtils
await FileUtils.Initialize(newTrack.ScreenInfo);
var missingFiles = await AudioUtils.GetMissingFiles(newTrack);
// Add playback items to the list
QuranAudioTrack nextTrack = newTrack.GetFirstAyah();
var reciter = nextTrack.GetReciter();
while (nextTrack != null)
{
string fileName = AudioUtils.GetFileName(nextTrack.GetQuranAyah(), reciter);
MediaSource source;
if (missingFiles.Contains(fileName))
{
source = MediaSource.CreateFromUri(new Uri(Path.Combine(reciter.ServerUrl, fileName)));
}
else
{
var file = await FileUtils.GetFile(await reciter.GetStorageFolder(), fileName);
if (file != null)
{
source = MediaSource.CreateFromStorageFile(file);
//source = MediaSource.CreateFromUri(new Uri(file.Path));
}
else
{
source = MediaSource.CreateFromUri(new Uri(Path.Combine(reciter.ServerUrl, fileName)));
}
}
source.CustomProperties[SurahKey] = nextTrack.Surah;
source.CustomProperties[AyahKey] = nextTrack.Ayah;
source.CustomProperties[ReciterKey] = nextTrack.ReciterId;
source.CustomProperties[QuranTrackKey] = nextTrack.ToString();
source.CustomProperties[TitleKey] = QuranUtils.GetSurahAyahString(nextTrack.Surah, nextTrack.Ayah);
_playbackList.Items.Add(new MediaPlaybackItem(source));
nextTrack = nextTrack.GetNextInSurah();
}
// Don't auto start
BackgroundMediaPlayer.Current.AutoPlay = false;
// Assign the list to the player
BackgroundMediaPlayer.Current.Source = _playbackList;
// Add handler for future playlist item changes
_playbackList.CurrentItemChanged += PlaybackListCurrentItemChanged;
}
private void Scenario1_Loaded(object sender, RoutedEventArgs e)
{
// Create a new playback list
if (PlaybackList == null)
PlaybackList = new MediaPlaybackList();
}
/// <summary>
/// Raised when playlist changes to a new track
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
//Uri s = GetCurrentTrackId();
// Get the new item
var item = args.NewItem;
Debug.WriteLine("PlaybackList_CurrentItemChanged: " + (item == null ? "null" : Convert.ToString(GetTrackId(item))));
// Update the system view
UpdateUVCOnNewTrack(item);
// Get the current track
Uri currentTrackId = null;
if (item != null)
{
string trackIdKey = item.Source.CustomProperties[TrackIdKey].ToString();
currentTrackId = new Uri(trackIdKey);
}
ApplicationSettingsHelper.SaveSettingsValue(ApplicationSettingsConstants.TrackId, currentTrackId == null ? null : currentTrackId.ToString());
MessageService.SendMessageToForeground(new TrackChangedMessage(currentTrackId));
}
public MediaPlaybackListEvents(MediaPlaybackList This)
{
this.This = This;
}
private async void PlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
{
var item = args.NewItem;
// Update the system view
if (item == null)
return;
var currentTrackId = item.Source.CustomProperties[TrackIdKey] as string;
UpdateUVCOnNewTrack(item);
// Get the current track
// Notify foreground of change or persist for later
MessageService.SendMessageToForeground(new BackPlaybackChangedMessage(NowState, Songs.Find(x => x.MainKey == currentTrackId)));
ThreadPool.RunAsync(async (work) =>
{
var bytestream = await FileHelper.FetchArtwork(FileList.Find(x => currentTrackId == ((StorageFile)x).Path));
if (bytestream != null)
{
MessageService.SendMessageToForeground(new UpdateArtworkMessage(bytestream));
UpdateUVCOnNewTrack(bytestream);
}
});
}
/// <summary>
/// Create a playback list from the list of songs received from the foreground app.
/// </summary>
/// <param name="songs"></param>
void CreatePlaybackList(IEnumerable<SoundCloudTrack> songs)
{
// Make a new list and enable looping
playbackList = new MediaPlaybackList();
playbackList.AutoRepeatEnabled = true;
// Add playback items to the list
foreach (var song in songs)
{
if (!string.IsNullOrEmpty(song.stream_url))
{
var source = MediaSource.CreateFromUri(new Uri(song.stream_url.ToString()));
source.CustomProperties[TrackIdKey] = song.stream_url.ToString();
source.CustomProperties[TitleKey] = song.title;
source.CustomProperties[AlbumArtKey] = song.AlbumArtUri;
playbackList.Items.Add(new MediaPlaybackItem(source));
}
}
// Don't auto start
BackgroundMediaPlayer.Current.AutoPlay = false;
// Assign the list to the player
BackgroundMediaPlayer.Current.Source = playbackList;
// Add handler for future playlist item changes
playbackList.CurrentItemChanged += PlaybackList_CurrentItemChanged;
}
public async Task Play(string url, MediaFileType fileType)
{
_loadMediaTaskCompletionSource = new TaskCompletionSource<bool>();
try
{
if (_currentMediaSource != null)
{
_currentMediaSource.StateChanged -= MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted -= MediaSourceOnOpenOperationCompleted;
}
// Todo: sync this with the playback queue
var mediaPlaybackList = new MediaPlaybackList();
_currentMediaSource = await CreateMediaSource(url, fileType);
_currentMediaSource.StateChanged += MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted += MediaSourceOnOpenOperationCompleted;
var item = new MediaPlaybackItem(_currentMediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception)
{
Debug.WriteLine("Unable to open url: " + url);
}
}
private void PlaybackList_ItemFailed(MediaPlaybackList sender, MediaPlaybackItemFailedEventArgs args)
{
throw new NotImplementedException();
}
