public async Task UpdateNowPlaying(QueueSong queue) { try { await _service.ScrobbleNowPlayingAsync(queue.Song.Name, queue.Song.Artist.Name, DateTime.UtcNow, queue.Song.Duration); } catch { } }
public static async void PlaySong(QueueSong queueSong) { if (queueSong == null) return; // Insights.Track("Play Song", new Dictionary<string, string> // { // {"Name",queueSong.Song.Name}, // {"ArtistName",queueSong.Song.ArtistName}, // {"ProviderId",queueSong.Song.ProviderId} // }); if (!App.Current.AudioServiceConnection.IsPlayerBound) { if (!await App.Current.StartPlaybackServiceAsync()) return; } App.Current.AudioServiceConnection.GetPlaybackService().PlaySong(queueSong); }
private async Task AddToQueueAsync(Song song) { if (QueueSongs.Any(p => p.SongId == song.Id)) return; var prev = QueueSongs.LastOrDefault(); // Create the new queue entry var newQueue = new QueueSong { SongId = song.Id, PrevId = prev == null ? 0 : prev.Id, Song = song }; using (var bg = _bgFunc()) { await bg.InsertAsync(newQueue); if (prev != null) { prev.NextId = newQueue.Id; await bg.UpdateItemAsync(prev); } QueueSongsLookup.Add(newQueue.Id, newQueue); QueueSongs.Add(newQueue); } }
public async Task DeleteFromQueueAsync(QueueSong songToRemove) { QueueSong previousModel; if (songToRemove == null) { return; } if (_lookupMap.TryGetValue(songToRemove.PrevId, out previousModel)) { previousModel.NextId = songToRemove.NextId; await _bgSqlService.UpdateItemAsync(previousModel); } if (_lookupMap.TryGetValue(songToRemove.ShufflePrevId, out previousModel)) { previousModel.ShuffleNextId = songToRemove.ShuffleNextId; await _bgSqlService.UpdateItemAsync(previousModel); } QueueSong nextModel; if (_lookupMap.TryGetValue(songToRemove.NextId, out nextModel)) { nextModel.PrevId = songToRemove.PrevId; await _bgSqlService.UpdateItemAsync(nextModel); } if (_lookupMap.TryGetValue(songToRemove.ShuffleNextId, out nextModel)) { nextModel.ShufflePrevId = songToRemove.ShufflePrevId; await _bgSqlService.UpdateItemAsync(nextModel); } await _dispatcher.RunAsync( () => { PlaybackQueue.Remove(songToRemove); ShufflePlaybackQueue.Remove(songToRemove); }); _lookupMap.TryRemove(songToRemove.Id, out songToRemove); // Delete from database await _bgSqlService.DeleteItemAsync(songToRemove); }
public async Task<QueueSong> AddToQueueAsync(Song song, QueueSong position = null, bool shuffleInsert = true) { if (song == null) { return null; } var rnd = new Random(DateTime.Now.Millisecond); QueueSong prev = null; QueueSong shufflePrev = null; QueueSong next = null; QueueSong shuffleNext = null; var shuffleIndex = -1; var normalIndex = -1; if (position != null) { shuffleIndex = ShufflePlaybackQueue.IndexOf(position) + 1; normalIndex = PlaybackQueue.IndexOf(position) + 1; } var insert = normalIndex > -1 && normalIndex < PlaybackQueue.Count; var insertShuffle = shuffleIndex > -1 && shuffleInsert; var shuffleLastAdd = shuffleIndex == ShufflePlaybackQueue.Count; if (insert) { next = PlaybackQueue.ElementAtOrDefault(normalIndex); if (next != null) { _lookupMap.TryGetValue(next.PrevId, out prev); } } else { prev = PlaybackQueue.LastOrDefault(); } if (insertShuffle) { if (shuffleLastAdd) { shufflePrev = ShufflePlaybackQueue.ElementAtOrDefault(ShufflePlaybackQueue.Count - 1); } else { shuffleNext = ShufflePlaybackQueue.ElementAtOrDefault(shuffleIndex); if (shuffleNext != null) { _lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev); } } } else { if (ShufflePlaybackQueue.Count > 1) { shuffleIndex = rnd.Next(1, ShufflePlaybackQueue.Count - 1); shuffleNext = ShufflePlaybackQueue.ElementAt(shuffleIndex); _lookupMap.TryGetValue(shuffleNext.ShufflePrevId, out shufflePrev); } else { shuffleLastAdd = true; shufflePrev = prev; } } // Create the new queue entry var newQueue = new QueueSong { SongId = song.Id, NextId = next == null ? 0 : next.Id, PrevId = prev == null ? 0 : prev.Id, ShuffleNextId = shuffleNext == null ? 0 : shuffleNext.Id, ShufflePrevId = shufflePrev == null ? 0 : shufflePrev.Id, Song = song }; // Add it to the database await _bgSqlService.InsertAsync(newQueue).ConfigureAwait(false); if (next != null) { // Update the prev id of the queue that was replaced next.PrevId = newQueue.Id; await _bgSqlService.UpdateItemAsync(next).ConfigureAwait(false); } if (prev != null) { // Update the next id of the previous tail prev.NextId = newQueue.Id; await _bgSqlService.UpdateItemAsync(prev).ConfigureAwait(false); } if (shuffleNext != null) { shuffleNext.ShufflePrevId = newQueue.Id; await _bgSqlService.UpdateItemAsync(shuffleNext).ConfigureAwait(false); } if (shufflePrev != null) { shufflePrev.ShuffleNextId = newQueue.Id; await _bgSqlService.UpdateItemAsync(shufflePrev).ConfigureAwait(false); } // Add the new queue entry to the collection and map await _dispatcher.RunAsync( () => { if (insert) { try { PlaybackQueue.Insert(normalIndex, newQueue); } catch (ArgumentOutOfRangeException) { PlaybackQueue.Add(newQueue); } } else { PlaybackQueue.Add(newQueue); } if (shuffleLastAdd || !shuffleInsert) { ShufflePlaybackQueue.Add(newQueue); } else { try { ShufflePlaybackQueue.Insert(shuffleIndex, newQueue); } catch (ArgumentOutOfRangeException) { ShufflePlaybackQueue.Add(newQueue); } } }).ConfigureAwait(false); _lookupMap.TryAdd(newQueue.Id, newQueue); return newQueue; }
public async void PlaySong(QueueSong song) { if (song == null || song.Song == null) { CurtainPrompt.ShowError("Song seems to be empty..."); return; } Insights.Track( "Play Song", new Dictionary<string, string> { {"Name", song.Song.Name}, {"ArtistName", song.Song.ArtistName}, {"ProviderId", song.Song.ProviderId} }); if (_isShutdown) { await AddMediaPlayerEventHandlers(); } _appSettings.Write("RadioId", null); _appSettings.Write("RadioMode", false); _appSettings.Write(PlayerConstants.CurrentTrack, song.Id); var message = new ValueSet {{PlayerConstants.StartPlayback, null}}; BackgroundMediaPlayer.SendMessageToBackground(message); RaiseEvent(TrackChanged); }
public async void PlaySong(QueueSong queue) { _appSettingsHelper.Write(PlayerConstants.CurrentTrack, queue.Id); if (_alreadyStarted) _player.Reset(); else { StartForeground(NotificationId, BuildNotification()); } _alreadyStarted = true; try { await _player.SetDataSourceAsync(ApplicationContext, Uri.Parse(queue.Song.AudioUrl)); MediaPlayerState = MediaPlayerState.Buffering; _player.PrepareAsync(); } catch (Exception e) { MediaPlayerState = MediaPlayerState.None; Log.Error("MUSIC SERVICE", "Player error", e); } }
private async void InternalStartTrack(QueueSong track) { _transportControls.IsPreviousEnabled = !IsRadioMode; // If the flac media source adapter is not null, disposed of it // since we won't be using it if (_currentMediaSourceAdapter != null) { _currentMediaSourceAdapter.Dispose(); _currentMediaSourceAdapter = null; } if (track.Song.IsStreaming) { _mediaPlayer.SetUriSource(new Uri(track.Song.AudioUrl)); } else { var file = await StorageFile.GetFileFromPathAsync(track.Song.AudioUrl); if (file != null) { try { if (file.FileType != ".flac") { _mediaPlayer.SetFileSource(file); } else { // Use custom media source for FLAC support _currentMediaSourceAdapter = await FlacMediaSourceAdapter.CreateAsync(file); BackgroundMediaPlayer.Current.SetMediaSource(_currentMediaSourceAdapter.MediaSource); } } catch { SkipToNext(); } } else if (CurrentTrack.NextId != 0 && CurrentTrack.PrevId != 0) SkipToNext(); } _mediaPlayer.Play(); }
public async void StartTrack(QueueSong track, bool ended = false) { if (track == null) return; try { ScrobbleOnMediaEnded(); } catch { } if (IsRadioMode && _station != null && _currentTrack != null && _currentTrack.Song.ProviderId.Contains("gn.")) { // Create the station manager var radioStationManager = new RadioStationManager(_station.GracenoteId, _station.Id, CreateCollectionSqlService, CreatePlayerSqlService); var trackId = _currentTrack.Song.ProviderId.Replace("gn.", ""); if (!ended) await radioStationManager.SkippedAsync(trackId); else await radioStationManager.PlayedAsync(trackId); await radioStationManager.UpdateQueueAsync(); track = radioStationManager.QueueSongs[0]; _appSettingsHelper.Write(PlayerConstants.CurrentTrack, track.Id); OnEvent(QueueUpdated); } _currentTrack = track; UpdateTile(); if (TrackChanged != null) OnTrackChanged(_currentTrack.SongId); _mediaPlayer.Pause(); if (_mediaPlayer.Position > TimeSpan.Zero) _mediaPlayer.Position = TimeSpan.Zero; _transportControls.PlaybackStatus = MediaPlaybackStatus.Changing; if (IsRadioMode) StartRadioTrack(track); else InternalStartTrack(track); }
public async void StartRadioTrack(QueueSong track) { if (track == null) return; switch (track.Song.SongState) { case SongState.BackgroundMatching: _transportControls.IsPlayEnabled = false; _transportControls.IsNextEnabled = false; _transportControls.IsPreviousEnabled = false; OnEvent(MatchingTrack); // Create the station manager var radioStationManager = new RadioStationManager(_station.GracenoteId, _station.Id, CreateCollectionSqlService, CreatePlayerSqlService); var matched = await radioStationManager.MatchSongAsync(track.Song); _transportControls.IsNextEnabled = true; if (!matched) { SkipToNext(); return; } break; case SongState.NoMatch: SkipToNext(); break; } InternalStartTrack(track); }
public Task DeleteFromQueueAsync(QueueSong songToRemove) { throw new NotImplementedException(); }
public Task<QueueSong> AddToQueueAsync(Song song, QueueSong position = null, bool shuffleInsert = true) { throw new NotImplementedException(); }