// 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(); }