/// <summary>
/// Pauses or plays the music.
/// </summary>
/// <returns>A boolean indicating whether the music is playing.</returns>
public bool TogglePlay(bool?pause = null)
{
var result = false;
if (_waveOutDevice != null && _currentSong != null)
{
if ((_waveOutDevice.PlaybackState == PlaybackState.Playing && pause != false) || pause == true)
{
_currentSong.IsPlaying = false;
_waveOutDevice.Pause();
}
else if (_playStream != null)
{
_waveOutDevice.Play();
_currentSong.IsPlaying = true;
_timeTracker?.Abort();
if (!_currentSong.IsInternetRadio)
{
_timeTracker = new Thread(UpdateTime);
_timeTracker.Start();
}
result = true;
}
SongChanged?.Invoke(_currentSong);
}
return(result);
}
private void FireSongChangeEvent()
{
if (SongChanged != null)
{
SongChanged.Invoke(this, EventArgs.Empty);
}
}
private PlaylistItem AdvancePlaylist()
{
PlaylistItem item = Program.Core.DataSource.CurrentItem = Program.Mover.Next();
SongChanged?.Invoke(this, item);
return(item);
}
public async Task Previous()
{
QueueItem nowPlaying = await GetNowPlaying();
int i = Queue.IndexOf(nowPlaying);
Queue[i].NowPlaying = false;
Queue[i].Position = 0;
if (i == 0)
{
if (RepeatAll)
{
Queue[Queue.Count - 1].NowPlaying = true;
}
else
{
await Stop();
}
}
else
{
Queue[i - 1].NowPlaying = true;
}
SongChanged.Invoke(this, null);
if (PlayerState == StatePlaying)
{
await Play();
}
}
/// <summary>
/// Load a song
/// </summary>
/// <param name="path">the absolute path</param>
private void Load(string path)
{
try
{
DisposeWaveOut(true);
_playStream?.Dispose();
_playStream = new MediaFoundationReader(path);
if (_playStream == null)
{
return;
}
_waveOutDevice.Init(_playStream);
_currentSong.Duration = Convert.ToInt64(_playStream.TotalTime.TotalSeconds);
SongChanged?.Invoke(_currentSong);
TogglePlay();
}
catch (Exception e)
{
Logger.LogError(e, "MusicPlayer: Could not load song " + path);
_playStream = null;
if (!_isReceiveMode)
{
Next();
}
}
}
private void OnSongChanged(SongChangeMode songChangeMode)
{
if (SongChanged != null)
{
SongChanged.Invoke(songChangeMode);
}
}
/// <summary>
/// Start playing a track by getting the download URL from onedrive and passing it to the native MediaPlayer
/// </summary>
/// <param name="track"></param>
/// <returns></returns>
public async Task <bool> Play(Track track, int postition = 0)
{
string url = await App.OneDrive.GetTrackURL(track.OneDrive_ID);
SongChanged.Invoke(this, null);
DependencyService.Get <PlayMusic>().Play(url, postition);
PlayerState = StatePlaying;
return(true);
}
public async Task <bool> Play()
{
QueueItem queueItem = await GetNowPlaying();
string url = await App.OneDrive.GetTrackURL((await queueItem.GetTrack()).OneDrive_ID);
SongChanged.Invoke(this, null);
DependencyService.Get <PlayMusic>().Play(url, queueItem.Position);
PlayerState = StatePlaying;
return(true);
}
/// <summary>
/// Connects to SignalR
/// </summary>
public async Task ConnectAsync()
{
connection = new HubConnectionBuilder()
.WithUrl(_hubUrl)
.Build();
connection.On <CurrentlyPlaying>("SongChanged", (song) => SongChanged?.Invoke(song));
connection.On <PlaylistItem>("PlaylistChanged", (playlist) => PlaylistChanged?.Invoke(playlist));
connection.On <int>("VolumeChanged", (volume) => VolumeChanged?.Invoke(volume));
connection.On("Paused", () => Paused?.Invoke());
connection.On("Resumed", () => Resumed?.Invoke());
await connection.StartAsync();
}
void AddNewMessage(JObject message)
{
try
{
if (Variables.NowPlaying != null)
{
previousSong = Variables.NowPlaying;
}
string id = message.GetValue("SongId").ToString();
string title = message.GetValue("SongTitle").ToString();
string artist = message.GetValue("ArtistName").ToString();
string album = message.GetValue("AlbumTitle").ToString();
string length = message.GetValue("SongLength").ToString();
string songUrl = message.GetValue("SongUrl").ToString();
string artistId = message.GetValue("ArtistId").ToString();
string twitter = message.GetValue("ArtistTwitterUrl").ToString();
string facebook = message.GetValue("ArtistFacebookUrl").ToString();
string albumImage = message.GetValue("AlbumImage").ToString();
Variables.NowPlaying = new SongModel
{
Id = id,
SongTitle = title,
ArtistName = artist,
AlbumTitle = album,
SongLength = length,
SongUrl = songUrl,
ArtistId = artistId,
ArtistTwitterUrl = twitter,
ArtistFacebookUrl = facebook,
AlbumImage = albumImage,
};
if (previousSong != null)
{
if (previousSong != Variables.NowPlaying)
{
Variables.PreviouslyPlayed.Insert(0, Variables.NowPlaying);
Variables.PreviouslyPlayed.RemoveAt(Variables.PreviouslyPlayed.Count - 1);
}
}
//App.STVM.CurrentSong = Variables.CurrentSong;
SongChanged?.Invoke(this, Variables.NowPlaying);
}
catch (Exception e)
{
Console.WriteLine("Sig R Obj Creation error" + e.Message);
}
Console.WriteLine(Variables.NowPlaying.SongTitle);
}
/// <summary>
/// Update the data about the currently playing song
/// </summary>
private void UpdateSongData()
{
string filename = SendIPCCommandString(IPCCommand.GetFilename);
if (CurrentSong.Filename == filename)
{
return;
}
bool hasMetadata = true;
string title = GetMetadata(filename, "title");
if (string.IsNullOrEmpty(title))
{
title = SendIPCCommandString(IPCCommand.GetTitle);
hasMetadata = false;
}
string artist = string.Empty;
string year = string.Empty;
string album = string.Empty;
string track = string.Empty;
if (hasMetadata)
{
artist = GetMetadata(filename, "Artist");
year = GetMetadata(filename, "Year");
album = GetMetadata(filename, "Album");
track = GetMetadata(filename, "Track");
}
Song song = new Song
{
HasMetadata = hasMetadata,
Filename = filename,
Title = title,
Artist = artist,
Album = album,
Year = year,
Track = track
};
CurrentSong = song;
SongChanged?.Invoke(this, new SongChangedEventArgs(song));
}
private void CheckIfSongChanged()
{
Process spotify = SpotifyProcessManager.CurrentSpotifyProcess;
string newWindowTitle = spotify?.MainWindowTitle;
if (_oldWindowTitle != newWindowTitle)
{
_logger.Log($"Song changed: _oldWindowTitle = '{_oldWindowTitle}', newWindowTitle = '{newWindowTitle}'.");
var oldSong = LastSong;
UpdateListWithNewSong(newWindowTitle: newWindowTitle);
var newSong = LastSong;
_oldWindowTitle = newWindowTitle;
SongChanged?.Invoke(this, new SongChangeEventArgs(oldSong, newSong));
}
}
/// <summary>
/// Updates the position of the song.
/// </summary>
private void UpdateTime()
{
while (!_disposing && _waveOutDevice != null && _currentSong != null && _playstream != null &&
(_waveOutDevice.PlaybackState == PlaybackState.Paused || _waveOutDevice.PlaybackState == PlaybackState.Playing))
{
try
{
if (_waveOutDevice.PlaybackState == PlaybackState.Playing)
{
_currentSong.Position = Convert.ToInt64(_playstream.CurrentTime.TotalSeconds);
SongChanged?.Invoke(_currentSong);
}
ThreadExtensions.SaveSleep(1000);
}
catch
{
}
}
}
private async System.Threading.Tasks.Task HandleStationSongMetadataStage2Async(SongMetadata songMetadata)
{
ExtendedSongMetadata newMetadata = new ExtendedSongMetadata(songMetadata);
bool hasMoreMetadata = await NepApp.MetadataManager.FindAdditionalMetadataAsync(newMetadata);
CurrentSong = newMetadata;
CurrentSong.SongLength = newMetadata.SongLength;
RaisePropertyChanged(nameof(CurrentSong));
await History.AddSongAsync(CurrentSong);
SongChanged.Invoke(this, new NepAppSongChangedEventArgs(CurrentSong));
if (hasMoreMetadata)
{
ArtworkProcessor.UpdateArtworkMetadata();
}
else
{
ArtworkProcessor.ResetArtwork();
}
}
public async void Init(SongViewModel song)
{
//Initialize our picker object
castingPicker = new CastingDevicePicker();
//Set the picker to filter to video capable casting devices
castingPicker.Filter.SupportsAudio = true;
//Hook up device selected event
castingPicker.CastingDeviceSelected += CastingPicker_CastingDeviceSelected;
Song = song;
_lastSong = new Song()
{
ID = song.ID,
IsOnline = song.IsOnline,
OnlineUri = new Uri(song.FilePath),
FilePath = song.FilePath,
Duration = song.Song.Duration,
Album = song.Album,
OnlineAlbumID = song.Song.OnlineAlbumID,
OnlineID = song.Song.OnlineID
};
CurrentArtwork = song.Artwork;
lastUriPath = song.Artwork?.AbsolutePath;
IsPlaying = player.IsPlaying;
BufferProgress = MainPageViewModel.Current.BufferProgress;
SongChanged?.Invoke(song, EventArgs.Empty);
CurrentRating = song.Rating;
var brush = new SolidColorBrush(await ImagingHelper.GetMainColor(CurrentArtwork));
CurrentColorBrush = brush;
MainPageViewModel.Current.LeftTopColor = AdjustColorbyTheme(CurrentColorBrush);
CurrentIndex = MainPageViewModel.Current.CurrentIndex;
var task = ThreadPool.RunAsync(async x =>
{
var favor = await _lastSong.GetFavoriteAsync();
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
IsCurrentFavorite = favor;
});
});
var t = ThreadPool.RunAsync(async x =>
{
var ext = MainPageViewModel.Current.LyricExtension;
if (ext != null)
{
var result = await ext.ExecuteAsync(new ValueSet()
{
new KeyValuePair <string, object>("q", "lyric"),
new KeyValuePair <string, object>("title", Song.Title),
new KeyValuePair <string, object>("album", song.Album),
new KeyValuePair <string, object>("artist", Song.Song.Performers.IsNullorEmpty() ? null : Song.Song.Performers[0]),
new KeyValuePair <string, object>("ID", song.IsOnline ? song.Song.OnlineID : null)
});
if (result != null)
{
var l = new Lyric(LrcParser.Parser.Parse((string)result, Song.Song.Duration));
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
Lyric.New(l);
});
}
else
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
Lyric.Clear();
LyricHint = Consts.Localizer.GetString("NoLyricText");
});
}
}
else
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
{
Lyric.Clear();
LyricHint = Consts.Localizer.GetString("NoLyricText");
});
}
});
}
/// <summary>
/// Invoke the songChanged event.
/// </summary>
/// <param name="song">The song.</param>
public void InvokeSongChanged(SongInformation song)
{
SongChanged?.Invoke(song);
}
/// <summary>
/// Starts playing the Queue. In order to play a track, you must first add it to the Queue using <see cref="AddQueue(string)"/>.
/// </summary>
/// <param name="repeat">If true, avoids dequeuing the next track. Not to be used for anything other than the player.</param>
public void PlayMusic(bool repeat = false)
{
if (!repeat && Queue.Count != 0)
{
FilePath = Queue[QueuePosition];
}
QueuePosition++;
void PMusic()
{
//TODO: Check if FilePath is a file
//maybe we can use cd://2 for CD track 2, and anything else we can use the NAudio backend?
if (true)
{
currentBackend = new NAudioBackend(FilePath);
}
currentBackend.Play();
currentBackend.Volume = CurrentVolume;
currentBackend.OnPlaybackStopped += OnPlaybackStopped;
Playing = true;
}
try
{
if (Playing != true)
{
PMusic();
}
else
{
AvoidNextQueue = true;
StopMusic();
PMusic();
}
SongChanged?.Invoke(null,
EventArgs.Empty); // Now that playback has started without any issues, fire the song changed event.
}
catch (System.IO.FileNotFoundException)
{
var args = new PlaybackExceptionEventArgs {
Details = "That's not a valid file path!"
};
SongException?.Invoke(null, args);
}
catch (ArgumentException)
{
var args = new PlaybackExceptionEventArgs {
Details = "That's not a valid file path!"
};
SongException?.Invoke(null, args);
}
catch (System.Runtime.InteropServices.COMException)
{
var args = new PlaybackExceptionEventArgs {
Details = "This isn't a valid audio file!"
};
SongException?.Invoke(null, args);
}
catch (FormatException)
{
var args = new PlaybackExceptionEventArgs {
Details = "This audio file might be corrupt!"
};
SongException?.Invoke(null, args);
}
catch (InvalidOperationException)
{
var args = new PlaybackExceptionEventArgs {
Details = "This audio file uses VBR \nor might be corrupt!"
};
SongException?.Invoke(null, args);
}
catch (Exception e)
{
var args = new PlaybackExceptionEventArgs {
Details = $"{e.Message}\n{e.StackTrace}"
};
SongException?.Invoke(null, args);
}
}
private async void Player_StatusChanged(object sender, PlayingItemsChangedArgs e)
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, async() =>
{
IsPlaying = player.IsPlaying;
if (e.CurrentSong != null)
{
if (!_lastSong.IsIDEqual(e.CurrentSong))
{
Song = new SongViewModel(e.CurrentSong);
CurrentRating = Song.Rating;
SongChanged?.Invoke(Song, EventArgs.Empty);
if (Song.Artwork != null)
{
if (lastUriPath == Song.Artwork.AbsolutePath)
{
}
else
{
CurrentArtwork = Song.Artwork;
CurrentColorBrush = new SolidColorBrush(await ImagingHelper.GetMainColor(CurrentArtwork));
MainPageViewModel.Current.LeftTopColor = AdjustColorbyTheme(CurrentColorBrush);
lastUriPath = Song.Artwork.AbsolutePath;
}
}
else
{
CurrentArtwork = null;
CurrentColorBrush = new SolidColorBrush(new UISettings().GetColorValue(UIColorType.Accent));
MainPageViewModel.Current.LeftTopColor = AdjustColorbyTheme(CurrentColorBrush);
lastUriPath = null;
}
if (e.Items is IList <Song> l)
{
NowListPreview = $"{e.CurrentIndex + 1}/{l.Count}";
NowPlayingList.Clear();
for (int i = 0; i < l.Count; i++)
{
NowPlayingList.Add(new SongViewModel(l[i])
{
Index = (uint)i
});
}
if (e.CurrentIndex < NowPlayingList.Count)
{
CurrentIndex = e.CurrentIndex;
}
}
IsCurrentFavorite = await e.CurrentSong.GetFavoriteAsync();
}
}
});
if (e.CurrentSong != null)
{
if (!_lastSong.IsIDEqual(e.CurrentSong))
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
Lyric.Clear();
LyricHint = Consts.Localizer.GetString("LoadingLyricsText");
});
_lastSong = e.CurrentSong;
var ext = MainPageViewModel.Current.LyricExtension;
if (ext != null)
{
var result = await ext.ExecuteAsync(new ValueSet()
{
new KeyValuePair <string, object>("q", "lyric"),
new KeyValuePair <string, object>("title", Song.Title),
new KeyValuePair <string, object>("album", song.Album),
new KeyValuePair <string, object>("artist", Song.Song.Performers.IsNullorEmpty() ? null : Song.Song.Performers[0]),
new KeyValuePair <string, object>("ID", song.IsOnline ? song.Song.OnlineID : null)
});
if (result != null)
{
var l = new Lyric(LrcParser.Parser.Parse((string)result, Song.Song.Duration));
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
Lyric.New(l);
});
}
else
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
Lyric.Clear();
LyricHint = Consts.Localizer.GetString("NoLyricText");
});
}
}
else
{
await CoreApplication.MainView.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>
{
Lyric.Clear();
LyricHint = Consts.Localizer.GetString("NoLyricText");
});
}
}
}
}
private void OnSongChanged(Song song)
{
SongChanged?.Invoke(this, song);
}
