public async Task GoBack()
{
_isOpeningTrack = true;
if (CurrentPlaylist == null || !CurrentPlaylist.ContainsPlayableTracks())
{
return;
}
if (CurrentTrack == null)
{
OpenPlayable(await CurrentPlaylist.GetLastTrack(), CurrentPlaylist).Forget();
return;
}
if (_tempHistory.Count > 1) //Check if there are more than two tracks, because the current track is the last one in the list
{
_tempHistory.RemoveAt(_tempHistory.Count - 1); //This is the current track
var newTrack = _tempHistory.Last();
OpenPlayable(newTrack.Item2, newTrack.Item1, true, false, false).Forget();
}
else
{
OpenPlayable(await CurrentPlaylist.GetPreviousTrack(CurrentTrack), CurrentPlaylist, true, false, false)
.Forget();
}
}
public async Task PlayPause()
{
if (IsPlaying)
{
await Task.Run(() => AudioPlayerEngine.Pause());
IsPlaying = false;
await CurrentPlaylist.SetState(CurrentTrack.Track, AudioPlayerState.Paused);
}
else
{
TrackStateViewModel song;
if (CurrentPlaylist.CurrentEntry != null)
{
song = CurrentPlaylist.CurrentEntry;
}
else if (CurrentPlaylist.Count > 0)
{
song = CurrentPlaylist[0];
}
else
{
return;
}
await Play(song);
}
}
public PlaylistSidePaneContentViewModel(
MediaPlayer mediaPlayer,
HohoemaPlaylist playerModel,
PlaylistSettings playlistSettings,
PageManager pageManager
)
{
MediaPlayer = mediaPlayer;
HohoemaPlaylist = playerModel;
PlaylistSettings = playlistSettings;
PageManager = pageManager;
CurrentPlaylist = playerModel.CurrentPlaylist;
CurrentPlayingItem = playerModel.Player.Current;
CurrentPlaylistName = new ReactiveProperty <string>(CurrentWindowContextScheduler, HohoemaPlaylist.CurrentPlaylist?.Label)
.AddTo(_CompositeDisposable);
IsShuffleEnabled = PlaylistSettings.ToReactivePropertyAsSynchronized(x => x.IsShuffleEnable, CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsTrackRepeatModeEnable = PlaylistSettings.ObserveProperty(x => x.RepeatMode)
.Select(x => x == MediaPlaybackAutoRepeatMode.Track)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsListRepeatModeEnable = PlaylistSettings.ObserveProperty(x => x.RepeatMode)
.Select(x => x == MediaPlaybackAutoRepeatMode.List)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
IsTrackRepeatModeEnable.Subscribe(x =>
{
MediaPlayer.IsLoopingEnabled = x;
})
.AddTo(_CompositeDisposable);
IsReverseEnabled = PlaylistSettings.ToReactivePropertyAsSynchronized(x => x.IsReverseModeEnable, CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoBack = HohoemaPlaylist.Player.ObserveProperty(x => x.CanGoBack)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistCanGoNext = HohoemaPlaylist.Player.ObserveProperty(x => x.CanGoNext)
.ToReactiveProperty(CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
PlaylistItems = CurrentPlaylist.Select(x =>
{
var video = Database.NicoVideoDb.Get(x);
return(new PlaylistItem()
{
ContentId = x,
Title = video.Title,
Owner = CurrentPlaylist,
Type = PlaylistItemType.Video
});
}).ToObservable()
.ToReadOnlyReactiveCollection(scheduler: CurrentWindowContextScheduler)
.AddTo(_CompositeDisposable);
RaisePropertyChanged(nameof(PlaylistItems));
}
private TrackStateViewModel GetRandom()
{
if (CurrentPlaylist.MoveRandom())
{
return(CurrentPlaylist.CurrentEntry);
}
return(null);
}
public async void GoForward()
{
if (CurrentPlaylist == null || CurrentPlaylist.Tracks.Count == 0)
{
return;
}
PlayableBase nextTrack;
if (Queue.HasTracks)
{
var tuple = Queue.PlayNextTrack();
nextTrack = tuple.Item1;
CurrentPlaylist = tuple.Item2;
}
else
{
int currenttrackindex = CurrentPlaylist.Tracks.IndexOf(CSCoreEngine.CurrentTrack);
int nexttrackindex = currenttrackindex;
if (CheckIfTracksExists(CurrentPlaylist))
{
if (IsShuffleEnabled)
{
nextTrack = CurrentPlaylist.GetRandomTrack(CSCoreEngine.CurrentTrack);
if (nextTrack == null)
{
return;
}
}
else
{
while (true)
{
nexttrackindex++;
if (CurrentPlaylist.Tracks.Count - 1 < nexttrackindex)
{
nexttrackindex = 0;
}
if (CurrentPlaylist.Tracks[nexttrackindex].TrackExists)
{
break;
}
}
nextTrack = CurrentPlaylist.Tracks[nexttrackindex];
}
}
else
{
return;
}
}
if (nextTrack.TrackExists)
{
if (await CSCoreEngine.OpenTrack(nextTrack))
{
CSCoreEngine.TogglePlayPause();
}
}
}
public void RemoveTrack(int index)
{
var media = mPlayer.currentPlaylist.Item[index];
var count = CurrentPlaylist.count;
CurrentPlaylist.removeItem(media);
var countafter = CurrentPlaylist.count;
SetCurrentPlaylistSongUrl(CurrentPlaylist);
}
private void Unsubscribe(IEnumerable <IPlaylist> playlists)
{
foreach (IPlaylist playlist in playlists ?? Enumerable.Empty <IPlaylist>())
{
CurrentPlaylist.Unsubscribe(playlist);
OtherPlaylists.Unsubscribe(playlist);
AllPlaylists.Unsubscribe(playlist);
}
}
private void OnCurrentPlaylistChanged(object sender, CurrentPlaylistChangedEventArgs e)
{
CurrentPlaylist.Unsubscribe(e.OldCurrentPlaylist);
CurrentPlaylist.Subscribe(e.NewCurrentPlaylist);
OtherPlaylists.Unsubscribe(e.NewCurrentPlaylist);
OtherPlaylists.Subscribe(e.OldCurrentPlaylist);
CurrentPlaylistChanged?.Invoke(this, new SubscriptionsEventArgs <ILibrary, CurrentPlaylistChangedEventArgs>(sender, e));
}
/// <summary>
/// Adds Items to the Playlist.
/// </summary>
/// <param name="item">
/// A Playlistem Object.
/// </param>
public static void PlaylistAddItems(MediaItem item)
{
//if (item.IsDir)
//{
// AddDir(item.AlbumID);
//}
//else
//{
// CurrentPlaylist.Add(item);
//}
CurrentPlaylist.Add(item);
Playback.AddToPlaylist(item);
}
public void UpdateCurrentPlaylistIndexAndRest()
{
UpdatePlaylistIndex();
NotifyPropertyChanged("CurrentPlaylist");
CurrentPlaylist.UpdateName();
CurrentPlaylist.UpdateSongsAndShuffleListSongs();
CurrentPlaylist.UpdateCurrentSong();
CurrentPlaylist.UpdateLoopIcon();
CurrentPlaylist.UpdateShuffleIcon();
}
/// <summary>
/// Adds the specified song to the end of the playlist.
/// This method is only available in administrator mode.
/// </summary>
/// <param name="songList">The songs to add to the end of the playlist.</param>
public void AddSongsToPlaylist(IEnumerable <Song> songList)
{
if (songList == null)
{
Throw.ArgumentNullException(() => songList);
}
CurrentPlaylist.AddSongs(songList.ToList());
// Copy the sequence to a list, so that the enumeration doesn't gets modified
PlaylistChanged.RaiseSafe(this, EventArgs.Empty);
}
void RemoveSelecurrent(Track track)
{
if (CurrentTrack == track)
{
Stop();
if (!IsLoopOne)
{
PlayForward();
}
}
CurrentPlaylist.RemoveTrack(track);
SelectedPlaylist.RemoveTrack(track);
}
/// <summary>
/// Stops playlist creation
/// </summary>
public void Stop()
{
// stop scanning
ScanTimer.Stop();
// save current playlist
if (CurrentPlaylist != null)
{
CurrentPlaylist.SavePlaylist(OutputFolder);
}
IsRunning = false;
}
void RemoveInAllSongs(Track track)
{
if (CurrentTrack == track)
{
Stop();
if (!IsLoopOne)
{
PlayForward();
}
}
CurrentPlaylist.RemoveTrack(track);
SelectedPlaylist.RemoveTrack(track);
Updater.DeleteOneTrack(track);
}
private void PlaylistElementClicked(object param)
{
PlayQueue.Content = CurrentPlaylist.GetRange(SelectedPlaylistElem, CurrentPlaylist.Count - SelectedPlaylistElem);
DisplayingImage = false;
mediaPlayer.NowPlaying = PlayQueue.Content[0];
OnPropertyChanged("NowPlayingTitle");
OnPropertyChanged("NowPlayingArtist");
Console.WriteLine("Music in queue: " + PlayQueue.Content.Count);
CancelMedia();
this._myMediaElement.Source = new Uri(PlayQueue.Content[0].File);
Console.WriteLine("New source: " + this._myMediaElement.Source);
PlayMedia(null);
StartTimer();
}
public async Task PlayPrev()
{
IsPlaying = false;
AudioPlayerEngine.Stop();
await CurrentPlaylist.SetState(CurrentTrack, AudioPlayerState.None);
CurrentTrack = null;
TrackStateViewModel song = await Task.Run(() => GetPreviousSong(RepeatState, ShuffleState));
if (song != null)
{
await Play(song);
}
}
/// <summary>
/// Starts a new playlist by saving the current and creating new
/// </summary>
public void StartNewPlaylist()
{
// save playlist
if (CurrentPlaylist != null && !string.IsNullOrEmpty(OutputFolder))
{
CurrentPlaylist.SavePlaylist(OutputFolder);
}
// create new
CurrentPlaylist = new ZunePlaylist(DateTime.Now.ToString());
// reset created time
PlaylistCreated = DateTime.Now;
LastScan = DateTime.Now;
}
/// <summary>
/// Adds the song to the end of the playlist.
/// This method throws an exception, if there is an outstanding timeout.
/// </summary>
/// <param name="song">The song to add to the end of the playlist.</param>
public void AddSongToPlaylist(Song song)
{
if (song == null)
{
Throw.ArgumentNullException(() => song);
}
if (CurrentPlaylist == null)
{
CurrentPlaylist = new Playlist("Default");
}
CurrentPlaylist.AddSongs(new[] { song });
PlaylistChanged.RaiseSafe(this, EventArgs.Empty);
}
public void Sort(string attribute)
{
bool sortAsc = bool.Parse(CurrentPlaylist.getItemInfo("SortAscending"));
if (CurrentPlaylist.getItemInfo("SortAttribute").Equals(attribute))
{
CurrentPlaylist.setItemInfo("SortAscending", (!sortAsc).ToString());
}
else
{
CurrentPlaylist.setItemInfo("SortAttribute", attribute);
CurrentPlaylist.setItemInfo("SortAscending", "true");
}
SetCurrentPlaylistSongUrl(CurrentPlaylist);
currentPlaylistSongUrl = PlaylistsUrl[CurrentPlaylist.name];
}
private void Subscribe(IEnumerable <IPlaylist> playlists)
{
foreach (IPlaylist playlist in playlists ?? Enumerable.Empty <IPlaylist>())
{
bool isCurrentPlaylist = Equals(playlist, playlist.Parent.Parent.CurrentPlaylist);
if (isCurrentPlaylist)
{
CurrentPlaylist.Subscribe(playlist);
}
else
{
OtherPlaylists.Subscribe(playlist);
}
AllPlaylists.Subscribe(playlist);
}
}
public TrackStateViewModel GetPreviousSong(bool repeat, bool random)
{
if (random)
{
return(GetRandom());
}
if (!repeat)
{
if (CurrentPlaylist.MovePrevious())
{
return(CurrentPlaylist.CurrentEntry);
}
}
else if (CurrentPlaylist.MovePreviousOrLast())
{
return(CurrentPlaylist.CurrentEntry);
}
return(null);
}
public TrackStateViewModel GetNextSong(bool repeat, bool random)
{
if (random)
{
return(GetRandom());
}
if (!repeat)
{
if (CurrentPlaylist.MoveNext())
{
return(CurrentPlaylist.CurrentEntry);
}
}
else if (CurrentPlaylist.MoveNextOrFirst())
{
return(CurrentPlaylist.CurrentEntry);
}
return(null);
}
/// <summary>
/// Scans the scan directory for new files and adds them to the playlist
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Scan()
{
// reset playlist
if (DateTime.Now.Subtract(PlaylistCreated) >= PlaylistCreationInterval)
{
StartNewPlaylist();
}
// get new files
List <string> newFiles = GetNewFiles();
// add new files to playlist
if (newFiles != null && newFiles.Count > 0)
{
newFiles.ForEach(nf => CurrentPlaylist.AddFileToPlaylist(nf));
}
// set current scan time
LastScan = DateTime.Now;
}
public static async Task PreparePlaylistAsync()
{
Debug.WriteLine("> Load playlist locally");
var loadedPlaylist = await LoadFromFileAsync();
if (CurrentPlaylist == null)
{
CurrentPlaylist = loadedPlaylist ?? new Playlist();
}
else
{
CurrentPlaylist.Clear();
if (loadedPlaylist.Entries.Count > 0)
{
CurrentPlaylist.Entries.AddRange(loadedPlaylist.Entries.ToList());
CurrentPlaylist.CurrentIndex = loadedPlaylist.CurrentIndex;
}
}
// Add waiting episodes
CurrentPlaylist.AddEpisodes(EpisodesToAdd);
// Cleanup
var wrongEpisodes = CurrentPlaylist.Entries.Where(e => e.Episode == null).ToArray();
foreach (var wrongEpisode in wrongEpisodes)
{
CurrentPlaylist.Entries.Remove(wrongEpisode);
}
// Check limits
if (CurrentPlaylist.CurrentIndex >= CurrentPlaylist.Entries.Count)
{
CurrentPlaylist.CurrentIndex = CurrentPlaylist.Entries.Count - 1;
}
if (CurrentPlaylist.CurrentIndex < 0 && CurrentPlaylist.Entries.Count > 0)
{
CurrentPlaylist.CurrentIndex = 0;
}
}
public async Task Play(TrackStateViewModel song)
{
if (CurrentTrack == null || !Equals(CurrentTrack, song))
{
if (CurrentPlaylist.MoveToEntry(song))
{
CurrentTrack = CurrentPlaylist.CurrentEntry;
await Task.Run(() =>
{
AudioPlayerEngine.Stop();
AudioPlayerEngine.Load(CurrentPlaylist.CurrentEntry.Track.Model);
AudioPlayerEngine.Play();
});
}
}
else
{
AudioPlayerEngine.Resume();
}
IsPlaying = true;
await CurrentPlaylist.SetState(song, AudioPlayerState.Playing);
}
private void InternPlayNextSong()
{
if (!CurrentPlaylist.CanPlayNextSong || !CurrentPlaylist.CurrentSongIndex.HasValue)
{
throw new InvalidOperationException("The next song couldn't be played.");
}
int nextIndex = CurrentPlaylist.CurrentSongIndex.Value + 1;
// We want the to swap the songs, if the song that should be played next is currently caching
if (CurrentPlaylist.ContainsIndex(nextIndex + 1))
{
PlaylistEntry nextReady = CurrentPlaylist
.Skip(nextIndex)
.FirstOrDefault();
if (nextReady != null)
{
CurrentPlaylist.InsertMove(nextReady.Index, nextIndex);
}
}
InternPlaySong(nextIndex);
}
public async Task GoForward(bool crossfade)
{
IPlayable track;
_isOpeningTrack = true;
if (Queue.QueueItems.Any())
{
track = Queue.GetNextPlayable();
QueuePlaying?.Invoke(this, EventArgs.Empty);
}
else
{
if (CurrentPlaylist == null || !CurrentPlaylist.ContainsPlayableTracks())
{
return;
}
track = await(CurrentPlayMode == PlayMode.Default
? CurrentPlaylist.GetNextTrack(CurrentTrack)
: CurrentPlaylist.GetShuffleTrack());
}
await OpenPlayable(track, CurrentPlaylist, true, crossfade, true);
}
async void chimneyMpdServer_OnLoad(object sender, ResponseEventArgs e)
{
string playlistName = string.Empty;
int start = 0;
int end = 0;
bool suc = false;
if (e.arguments.Count > 0)
{
playlistName = e.arguments[0];
if (e.arguments.Count > 1)
{
string[] par = e.arguments[1].Split(new char[] { ':' });
suc = int.TryParse(par[1], out start);
if (suc && par.Length > 1) suc = int.TryParse(par[2], out end);
else end = start;
}
}
var playlistToAddFrom = await Dbconnection.FindAsync<Playlist>(o => o.Name == playlistName);
if(!suc && playlistToAddFrom != null)
{
end = await Dbconnection.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM PlaylistFiles WHERE PlaylistId = " + playlistToAddFrom.PlaylistId);
}
if(playlistToAddFrom != null)
{
var plFiles = await Dbconnection.QueryAsync<PlaylistFile>("SELECT * FROM PlaylistFiles WHERE PlaylistId = " + playlistToAddFrom.PlaylistId
+ " AND Postion >= " + start + " AND Position < " + end);
foreach(PlaylistFile plFile in plFiles)
{
CurrentPlaylist newCurrentPlaylistItem = new CurrentPlaylist()
{
FileId = (plFile.IsUri) ? -1 : plFile.FileId,
IsUri = plFile.IsUri,
Uri = plFile.Uri,
PositionId = await Dbconnection.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM CurrentPlaylist")
};
await Dbconnection.InsertAsync(newCurrentPlaylistItem);
}
}
chimneyMpdServer.AppendResponse(string.Empty, e.id, e.position);
if (OnIdleEvent != null) OnIdleEvent(this, new IdleEventArgs("playlist"));
}
async void chimneyMpdServer_OnAdd(object sender, ResponseEventArgs e)
{
bool suc = true;
string uri = string.Empty;
File file = null;
bool addasUri = false;
if(e.arguments.Count > 0)
{
uri = e.arguments[0];
file = await Dbconnection.FindAsync<File>(o => o.RelativePath.Equals(uri));
if (file == null) addasUri = true;
}
if (file != null || addasUri)
{
CurrentPlaylist newCurrentPlaylistItem = new CurrentPlaylist()
{
FileId = (addasUri) ? -1 : file.FileId,
IsUri = addasUri,
Uri = (addasUri) ? uri : file.FilePath,
Bitrate = (addasUri) ? 0 : file.Bitrate,
PositionId = await Dbconnection.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM CurrentPlaylist")
};
await Dbconnection.InsertAsync(newCurrentPlaylistItem);
}
else
{
//
// Get the uri from arguments, if empty uri is empty
//
var directory = (e.arguments.Count > 0) ? await Dbconnection.Table<Directory>().Where(o => o.RelativePath.Equals(e.arguments[0])).FirstAsync() : null;
//
// Get the sub directories for the the uri directories
//
var subDirQuery = Dbconnection.Table<Directory>().Where(o => o.RelativePath.StartsWith(directory.RelativePath) || directory.RelativePath.Equals(string.Empty));
var subDirectories = await subDirQuery.ToListAsync();
foreach (Directory subdir in subDirectories)
{
//
// Get all files in the current uri
//
var subfiles = await Dbconnection.QueryAsync<File>("SELECT * FROM Files WHERE Files.DirectoryId = " + subdir.DirectoryId);
foreach (File subfile in subfiles)
{
CurrentPlaylist newCurrentPlaylistItem = new CurrentPlaylist()
{
FileId = subfile.FileId,
PositionId = await Dbconnection.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM CurrentPlaylist")
};
await Dbconnection.InsertAsync(newCurrentPlaylistItem);
}
}
}
if (suc) chimneyMpdServer.AppendResponse(string.Empty, e.id, e.position);
else
{
string errorfile = string.Empty;
if (e.arguments.Count > 0) errorfile = e.arguments.First<string>();
chimneyMpdServer.ErrorResponse(MPDKeyWords.Response.ACK + " [50@0] {add} could not add file:" + " \"" + errorfile + "\"", e.id, e.position);
}
if (OnIdleEvent != null) OnIdleEvent(this, new IdleEventArgs("playlist"));
}
async void chimneyMpdServer_OnAddId(object sender, ResponseEventArgs e)
{
bool suc = false;
int id = 0;
File file = null;
if (e.arguments.Count > 0)
{
string uri = e.arguments[0];
//var files = await Dbconnection.QueryAsync<File>("SELECT * FROM Files WHERE RelativePath = \"" + uri + "\"");
//file = (files.Count > 0) ? files[0] : null;
file = await Dbconnection.FindAsync<File>(o => o.RelativePath.Equals(uri));
//var query = Dbconnection.Table<File>().Where(o => o.RelativePath.Equals(uri));
//file = await query.FirstAsync();
}
int position = -1;
if (e.arguments.Count > 1) suc = int.TryParse(e.arguments[1], out position);
else suc = false;
position = (suc) ? position : -1;
if (file != null)
{
int currentPlaylistCount = await Dbconnection.ExecuteScalarAsync<int>("SELECT COUNT(*) FROM CurrentPlaylist");
position = (position <= currentPlaylistCount && position >= 0) ? position : currentPlaylistCount;
if (position != currentPlaylistCount)
{
var affectedFiles = await Dbconnection.QueryAsync<CurrentPlaylist>("UPDATE CurrentPlaylist SET PositionId=PositionId+1 WHERE PositionId >= " + position);
}
CurrentPlaylist newCurrentPlaylistItem = new CurrentPlaylist()
{
FileId = file.FileId,
PositionId = position,
Bitrate = file.Bitrate,
IsUri = false,
Uri = file.FilePath
};
await Dbconnection.InsertAsync(newCurrentPlaylistItem);
suc = true;
id = file.FileId;
}
if (suc)
{
chimneyMpdServer.AppendResponse("Id: " + id + "\n", e.id, e.position);
}
else
{
string errorfile = string.Empty;
if (e.arguments.Count > 0) errorfile = e.arguments.First<string>();
chimneyMpdServer.ErrorResponse(MPDKeyWords.Response.ACK + " [50@0] {add} could not add file:" + " \"" + errorfile + "\"", e.id, e.position);
}
if (OnIdleEvent != null) OnIdleEvent(this, new IdleEventArgs("playlist"));
}
public void Handle(List <Track> message)
{
CurrentPlaylist.AddRange(message);
}
public void PreviousTrack()
{
Play(CurrentPlaylist.Previous());
}
public void SkipTrack()
{
Play(CurrentPlaylist.Next());
}