void UpdateInfo()
{
if (task == null || task.Status != TaskStatus.Running)
{
var container = TinyIoC.TinyIoCContainer.Current;
IMessageProvider messageProvider = container.Resolve <IMessageProvider>(Naming.ContainerNSR.MESSAGE_PROVIDER);
task = System.Threading.Tasks.Task.Factory.StartNew(() =>
{
for (int i = 0; i < SelectedTracks.Count(); i++)
{
TrackVM item = SelectedTracks.ElementAt(i);
TracklistProvider.Instance.UpdateTrackTagInfo(item);
}
}).ContinueWith(o =>
{
RootDispatcher.Dispatcher.Invoke(() =>
{
string message = messageProvider.TrackInfoUpdated;
if (MessageUpdated != null)
{
MessageUpdated(this, new MessageEventArgs {
Message = message
});
}
});
});
}
}
void Play()
{
BASSActive status = AudioControllerService.Current.GetStreamStatus();
if (SelectedTracks.Count() > 0 && status == BASSActive.BASS_ACTIVE_STOPPED)
{
TracklistProvider.Instance.SetCurrentIndex(Tracks.IndexOf(SelectedTracks.First()));
AudioControllerService.Current.LoadFile(TracklistProvider.Instance.GetCurrentTrack().Location);
}
else
{
switch (status)
{
case BASSActive.BASS_ACTIVE_PLAYING:
AudioControllerService.Current.Pause();
break;
case BASSActive.BASS_ACTIVE_PAUSED:
AudioControllerService.Current.Play(false);
break;
default:
if (TracklistProvider.Instance.Tracks.Count > 0)
{
if (TracklistProvider.Instance.CurrentIndex < 0)
{
TracklistProvider.Instance.SetCurrentIndex(0);
}
AudioControllerService.Current.LoadFile(TracklistProvider.Instance.GetCurrentTrack().Location);
}
break;
}
if (status != BASSActive.BASS_ACTIVE_PLAYING && TracklistProvider.Instance.Tracks.Count == 0)
{
AddTrack();
if (TracklistProvider.Instance.Tracks.Count > 0)
{
TracklistProvider.Instance.SetCurrentIndex(0);
AudioControllerService.Current.LoadFile(TracklistProvider.Instance.GetCurrentTrack().Location);
//AudioControllerService.Instance.Play(false);
}
}
}
}
////----------------------------------------------------------------------------------------------------------------------
//internal void CurrentTrackGoToStart()
//{
// if (CurrentTrack != null)
// CurrentTrack.Position = 0;
//}
//----------------------------------------------------------------------------------------------------------------------
//private void SetCurrentTrack(TrackInfoViewModel pTrack)
//{
// SetSelection(pTrack);
// CurrentTrack = pTrack;
//}
//----------------------------------------------------------------------------------------------------------------------
public void SetSelection(TrackInfoViewModel pTrack)
{
if (SelectedTracks != null && SelectedTracks.Count > 0)
{
SelectedTracks.Clear();
SelectedTracks.Add(pTrack);
}
//else
//{
// SelectedTracks = new ObservableCollection<TrackInfoViewModel>();
// SelectedTracks.Add(pTrack);
//}
}
public override void Cleanup()
{
_artistsLoaded = _albumsLoaded = _songsLoaded = _genresLoaded = false;
_parentId = null;
Genres.Clear();
Songs.Clear();
Artists.Clear();
Albums.Clear();
SelectedTracks.Clear();
base.Cleanup();
}
void MoveTrack(DIRECTION direction)
{
//var selectedTracksOrdered = from selecteditem in SelectedTracks
// orderby Tracks.IndexOf(selecteditem)
// select selecteditem;
IEnumerable <TrackVM> selectedTracksOrdered;
switch (direction)
{
case DIRECTION.UP:
selectedTracksOrdered = SelectedTracks.OrderBy(i => Tracks.IndexOf(i));
foreach (TrackVM trackVM in selectedTracksOrdered)
{
int oldIndex = Tracks.IndexOf(trackVM);
if (oldIndex == 0)
{
break;
}
TracklistProvider.Instance.MoveTrack(oldIndex, oldIndex - 1);
}
break;
case DIRECTION.DOWN:
selectedTracksOrdered = SelectedTracks.OrderByDescending(i => Tracks.IndexOf(i));
int lastTrackIndex = TracklistProvider.Instance.Tracks.Count - 1;
foreach (TrackVM trackVM in selectedTracksOrdered)
{
int oldIndex = Tracks.IndexOf(trackVM);
if (oldIndex == lastTrackIndex)
{
break;
}
TracklistProvider.Instance.MoveTrack(oldIndex, oldIndex + 1);
}
break;
}
}
private void WireCommands()
{
ArtistPageLoaded = new RelayCommand(async() =>
{
if (_navigationService.IsNetworkAvailable && !_gotAlbums)
{
SetProgressBar(AppResources.SysTrayGettingAlbums);
await GetArtistInfo();
SetProgressBar();
}
});
AlbumPageLoaded = new RelayCommand(async() =>
{
if (_artistTracks.IsNullOrEmpty())
{
SetProgressBar("Getting tracks...");
try
{
if (SelectedArtist != null)
{
await GetArtistInfo();
AlbumTracks = _artistTracks.Where(x => x.ParentId == SelectedAlbum.Id)
.OrderBy(x => x.ParentIndexNumber)
.ThenBy(x => x.IndexNumber).ToList();
}
else
{
await GetAlbumTracks();
}
}
catch (Exception ex)
{
Log.ErrorException("AlbumPageLoaded", ex);
}
SetProgressBar();
}
});
AlbumTapped = new RelayCommand <BaseItemDto>(album =>
{
SelectedAlbum = album;
AlbumTracks = _artistTracks.Where(x => x.ParentId == SelectedAlbum.Id)
.OrderBy(x => x.IndexNumber)
.ToList();
});
AlbumPlayTapped = new RelayCommand <BaseItemDto>(album =>
{
var albumTracks = _artistTracks.Where(x => x.ParentId == album.Id)
.OrderBy(x => x.IndexNumber)
.ToList();
var newList = albumTracks.ToPlayListItems(_apiClient);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.SetPlaylistAsMsg));
});
SelectionChangedCommand = new RelayCommand <SelectionChangedEventArgs>(args =>
{
if (args.AddedItems != null)
{
foreach (var track in args.AddedItems.Cast <BaseItemDto>())
{
SelectedTracks.Add(track);
}
}
if (args.RemovedItems != null)
{
foreach (var track in args.RemovedItems.Cast <BaseItemDto>())
{
SelectedTracks.Remove(track);
}
}
SelectedTracks = SelectedTracks.OrderBy(x => x.IndexNumber).ToList();
});
AddToNowPlayingCommand = new RelayCommand(() =>
{
if (!SelectedTracks.Any())
{
return;
}
var newList = SelectedTracks.ToPlayListItems(_apiClient);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.AddToPlaylistMsg));
SelectedTracks = new List <BaseItemDto>();
App.ShowMessage(string.Format("{0} tracks added successfully", newList.Count));
IsInSelectionMode = false;
});
PlayItemsCommand = new RelayCommand(() =>
{
var newList = SelectedTracks.ToPlayListItems(_apiClient);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.SetPlaylistAsMsg));
});
PlaySongCommand = new RelayCommand <BaseItemDto>(song =>
{
if (song == null)
{
return;
}
var playlist = new List <PlaylistItem>
{
song.ToPlaylistItem(_apiClient)
};
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(playlist, Constants.Messages.SetPlaylistAsMsg));
});
AddRemoveFavouriteCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
SetProgressBar(AppResources.SysTrayAddingToFavourites);
CanUpdateFavourites = false;
item.UserData = await _apiClient.UpdateFavoriteStatusAsync(item.Id, AuthenticationService.Current.LoggedInUser.Id, !item.UserData.IsFavorite);
}
catch (HttpException ex)
{
Log.ErrorException("AddRemoveFavouriteCommand (Music)", ex);
App.ShowMessage("Error making your changes");
}
SetProgressBar();
CanUpdateFavourites = true;
});
PlayAllItemsCommand = new RelayCommand(() =>
{
if (_artistTracks.IsNullOrEmpty())
{
return;
}
var playlist = _artistTracks.ToPlayListItems(_apiClient);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(playlist, Constants.Messages.SetPlaylistAsMsg));
});
}
void RemoveTrack()
{
TracklistProvider.Instance.RemoveTracks(SelectedTracks.ToArray());
}
private void WireCommands()
{
ArtistPageLoaded = new RelayCommand(async() =>
{
if (NavigationService.IsNetworkAvailable && !_gotAlbums)
{
SetProgressBar(AppResources.SysTrayGettingAlbums);
await GetArtistInfo();
SetProgressBar();
}
});
AlbumPageLoaded = new RelayCommand(async() =>
{
if (_artistTracks.IsNullOrEmpty())
{
SetProgressBar(AppResources.SysTrayGettingTracks);
try
{
if (SelectedArtist != null)
{
await GetArtistInfo();
AlbumTracks = _artistTracks.Where(x => x.ParentId == SelectedAlbum.Id)
.OrderBy(x => x.ParentIndexNumber)
.ThenBy(x => x.IndexNumber).ToList();
}
else
{
await GetAlbumTracks();
}
}
catch (Exception ex)
{
Log.ErrorException("AlbumPageLoaded", ex);
}
SetProgressBar();
}
});
AlbumTapped = new RelayCommand <BaseItemDto>(album =>
{
SelectedAlbum = album;
AlbumTracks = _artistTracks.Where(x => x.ParentId == SelectedAlbum.Id)
.OrderBy(x => x.IndexNumber)
.ToList();
});
AlbumPlayTapped = new RelayCommand <BaseItemDto>(async album =>
{
var albumTracks = _artistTracks.Where(x => x.ParentId == album.Id)
.OrderBy(x => x.IndexNumber)
.ToList();
var newList = await albumTracks.ToPlayListItems(ApiClient, _playbackManager);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.SetPlaylistAsMsg));
});
SelectionChangedCommand = new RelayCommand <SelectionChangedEventArgs>(args =>
{
if (args.AddedItems != null)
{
foreach (var track in args.AddedItems.Cast <BaseItemDto>())
{
SelectedTracks.Add(track);
}
}
if (args.RemovedItems != null)
{
foreach (var track in args.RemovedItems.Cast <BaseItemDto>())
{
SelectedTracks.Remove(track);
}
}
SelectedTracks = SelectedTracks.OrderBy(x => x.IndexNumber).ToList();
SyncItemsCommand.RaiseCanExecuteChanged();
});
AddToNowPlayingCommand = new RelayCommand(async() =>
{
if (!SelectedTracks.Any())
{
return;
}
var newList = await SelectedTracks.ToPlayListItems(ApiClient, _playbackManager);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.AddToPlaylistMsg));
SelectedTracks = new List <BaseItemDto>();
App.ShowMessage(string.Format(AppResources.MessageTracksAddedSuccessfully, newList.Count));
IsInSelectionMode = false;
});
SyncItemsCommand = new RelayCommand(async() =>
{
var trackIds = SelectedTracks.Select(x => x.Id).ToList();
try
{
var request = SyncRequestHelper.CreateRequest(trackIds);
await SyncService.Current.AddJobAsync(request);
}
catch (HttpException ex)
{
Utils.HandleHttpException("SyncItemsCommand", ex, NavigationService, Log);
}
}, () => SelectedTracks.Any());
TakeOfflineCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
var request = SyncRequestHelper.CreateRequest(item.Id, item.Name);
await SyncService.Current.AddJobAsync(request);
}
catch (HttpException ex)
{
Utils.HandleHttpException("TakeOfflineCommand", ex, NavigationService, Log);
}
});
UnsyncCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
await SyncService.Current.UnsyncItem(item.Id);
}
catch (HttpException ex)
{
Utils.HandleHttpException("UnsyncCommand", ex, NavigationService, Log);
}
});
PlayItemsCommand = new RelayCommand(async() =>
{
var newList = await SelectedTracks.ToPlayListItems(ApiClient, _playbackManager);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(newList, Constants.Messages.SetPlaylistAsMsg));
});
PlaySongCommand = new RelayCommand <BaseItemDto>(async song =>
{
if (song == null)
{
return;
}
var playlistItem = await song.ToPlaylistItem(ApiClient, _playbackManager);
var playlist = new List <PlaylistItem>
{
playlistItem
};
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(playlist, Constants.Messages.SetPlaylistAsMsg));
});
AddRemoveFavouriteCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
SetProgressBar(AppResources.SysTrayAddingToFavourites);
CanUpdateFavourites = false;
item.UserData = await ApiClient.UpdateFavoriteStatusAsync(item.Id, AuthenticationService.Current.LoggedInUserId, !item.UserData.IsFavorite);
}
catch (HttpException ex)
{
Utils.HandleHttpException("AddRemoveFavouriteCommand (Music)", ex, NavigationService, Log);
App.ShowMessage(AppResources.ErrorMakingChanges);
}
SetProgressBar();
CanUpdateFavourites = true;
});
PlayAllItemsCommand = new RelayCommand(async() =>
{
if (_artistTracks.IsNullOrEmpty())
{
return;
}
var playlist = await _artistTracks.ToPlayListItems(ApiClient, _playbackManager);
Messenger.Default.Send(new NotificationMessage <List <PlaylistItem> >(playlist, Constants.Messages.SetPlaylistAsMsg));
});
}
public void RemoveTrackFromStation(Track track)
{
SelectedTracks.Remove(track);
AllTracks.Add(track);
}
public void AttachTrackToStation(Track track)
{
SelectedTracks.Add(track);
AllTracks.Remove(track);
}
