protected async virtual Task AddToPlaylist(PlaylistActionContext managePlaylistContext)
        {
            await NavigationService.GoBackAsync(useModalNavigation : true);

            IEnumerable <Track> tracks = default;

            if (managePlaylistContext.Data is Track track)
            {
                tracks = Enumerable.Repeat(track, 1);
            }
            if (managePlaylistContext.Data is Album album)
            {
                tracks = album.Tracks;
            }
            if (managePlaylistContext.Data is PlaylistEntry playlistEntry)
            {
                tracks = Enumerable.Repeat(playlistEntry.Track, 1);
            }
            if (managePlaylistContext.Data is Playlist playlist)
            {
                tracks = playlist.Entries?.Select(t => t.Track);
            }

            if (tracks != null)
            {
                await AddTracksToPlaylist(managePlaylistContext, tracks);
            }
        }
        private async Task AddTracksToPlaylist(PlaylistActionContext managePlaylistContext, IEnumerable <Track> tracks)
        {
            var playlistTo = managePlaylistContext.PlaylistTo;

            if (playlistTo != null && tracks != null)
            {
                foreach (var track in tracks)
                {
                    if (track != null)
                    {
                        playlistTo.Entries.Add(new PlaylistEntry
                        {
                            PlaylistId = playlistTo.Id,
                            TrackId    = track.Id,
                            Guid       = Guid.NewGuid()
                        });
                    }
                }
                await _dataService.AppendToPlaylist(playlistTo);

                await _imageService.RemoveStitchedBitmaps(playlistTo.Id);

                managePlaylistContext.ActionMode = PlaylistActionMode.PlaylistUpdated;
                _eventAggregator.GetEvent <PlaylistActionContextChanged>().Publish(managePlaylistContext);
            }
        }
Пример #3
0
        private async Task AddToPlaylist(PlaylistActionContext context)
        {
            await NavigationService.GoBackAsync(useModalNavigation : true);

            if (context.Data is Track track)
            {
                var playlistTo = context.PlaylistTo;
                if (playlistTo != null && track != null)
                {
                    playlistTo.Entries.Add(new PlaylistEntry
                    {
                        PlaylistId = playlistTo.Id,
                        TrackId    = track.Id,
                        Guid       = Guid.NewGuid()
                    });

                    await _dataService.AppendToPlaylist(playlistTo);

                    await _imageService.RemoveStitchedBitmaps(playlistTo.Id);

                    context.ActionMode = PlaylistActionMode.PlaylistUpdated;
                    _eventAggregator.GetEvent <PlaylistActionContextChanged>().Publish(context);
                }
            }
        }
        private async Task CreateNewPlaylist(PlaylistActionContext context)
        {
            await NavigationService.GoBackAsync(useModalNavigation : true);

            var navigationParams = new NavigationParameters
            {
                { "source", context }
            };
            await NavigationService.NavigateAsync(nameof(NewPlaylistDialogPage), navigationParams, useModalNavigation : true);
        }
        protected async Task SelectPlaylist(PlaylistActionContext managePlaylistContext)
        {
            await _flyoutNavigationService.CloseFlyoutAsync();

            var navigationParams = new NavigationParameters
            {
                { "source", managePlaylistContext }
            };
            await NavigationService.NavigateAsync(nameof(PlaylistSelectorDialogPage), navigationParams, useModalNavigation : true);
        }
Пример #6
0
        public async override void OnNavigatedTo(INavigationParameters parameters)
        {
            _playlistActionContext = parameters.GetValue <PlaylistActionContext>("source");

            await CreatePlaylistFlyoutItems();

            IsBusy = false;

            base.OnNavigatedTo(parameters);
        }
        public override void OnNavigatedTo(INavigationParameters parameters)
        {
            _playlistActionContext = parameters.GetValue <PlaylistActionContext>("source");

            Device.BeginInvokeOnMainThread(async() =>
            {
                await CreatePlaylistFlyoutItems();
                IsBusy = false;
            });

            base.OnNavigatedTo(parameters);
        }
        private async Task RemovePlaylist(PlaylistActionContext managePlaylistContext)
        {
            await _flyoutNavigationService.CloseFlyoutAsync();

            if (managePlaylistContext.Data is Playlist playlist)
            {
                await _dataService.DeletePlaylist(playlist.Id);

                managePlaylistContext.ActionMode = PlaylistActionMode.PlaylistDeleted;

                _eventAggregator.GetEvent <PlaylistActionContextChanged>().Publish(managePlaylistContext);
            }
        }
Пример #9
0
        private async void OpenFlyout(object obj)
        {
            var source = new PlaylistActionContext
            {
                DisplayAlbumInfo = true,
                Data             = obj,
            };

            var navigationParams = new NavigationParameters {
                { "source", source }
            };

            await _flyoutNavigationService.ShowFlyoutAsync(nameof(PlaylistActionToolbarPage), navigationParams);
        }
        protected async virtual void OpenFlyout(object obj)
        {
            var source = new PlaylistActionContext
            {
                Data = obj,
            };

            if (obj is GridPanel item)
            {
                source.Data = item.Data;
            }

            var navigationParams = new NavigationParameters {
                { "source", source }
            };

            await FlyoutNavigationService.ShowFlyoutAsync(nameof(PlaylistActionToolbarPage), navigationParams);
        }
 protected virtual async Task RemoveFromPlaylist(PlaylistActionContext managePlaylistContext)
 {
     await _flyoutNavigationService.CloseFlyoutAsync();
 }