/// <summary>
        /// Navigates to the Audio Player screen with the requested file a parameter.
        /// </summary>
        /// <param name="file">The file to be played.</param>
        public async Task PlayAudioFile(StorageFile file)
        {
            Locator.NavigationService.Go(VLCPage.MusicPlayerPage);
            var trackItem = await MusicLibraryManagement.GetTrackItemFromFile(file);

            await PlaylistHelper.PlayTrackFromFilePicker(trackItem);
        }
        public override async void Execute(object parameter)
        {
            var items = (ObservableCollection <IStorageItem>)parameter;
            var files = new List <StorageFile>();

            foreach (var item in items)
            {
                var file = item as StorageFile;
                if (file != null && VLCFileExtensions.Supported.Contains(file.FileType.ToLower()))
                {
                    files.Add((StorageFile)item);
                }
            }
            var playlist = new ObservableCollection <IVLCMedia>();

            foreach (var file in files)
            {
                if (VLCFileExtensions.AudioExtensions.Contains(file.FileType.ToLower()))
                {
                    var trackItem = await MusicLibraryManagement.GetTrackItemFromFile(file);

                    playlist.Add(trackItem);
                }
                else if (VLCFileExtensions.VideoExtensions.Contains(file.FileType.ToLower()))
                {
                    var videoVm = new VideoItem();
                    await videoVm.Initialize(file);

                    playlist.Add(videoVm);
                }
            }
            await PlaylistHelper.AddTrackCollectionToPlaylistAndPlay(playlist, true, 0);
        }
Beispiel #3
0
        public async Task GetFavoriteAndRandomAlbums()
        {
            await MusicLibraryManagement.LoadFavoriteRandomAlbums();

            await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                OnPropertyChanged("RandomAlbums");
                OnPropertyChanged("FavoriteAlbums");
            });
        }
 public override async void Execute(object parameter)
 {
     if (parameter is TrackItem)
     {
         await MusicLibraryManagement.AddToPlaylist(parameter as TrackItem);
     }
     else if (parameter is AlbumItem)
     {
         await MusicLibraryManagement.AddToPlaylist(parameter as AlbumItem);
     }
 }
        public override async void Execute(object parameter)
        {
            var md = new MessageDialog("Your playlist will no longer be accessible", "Are you sure?");

            md.Commands.Add(new UICommand("yes", async command =>
            {
                await MusicLibraryManagement.DeletePlaylist(Locator.MusicLibraryVM.CurrentTrackCollection);
                Locator.NavigationService.GoBack_Specific();
            }));
            md.Commands.Add(new UICommand("no"));
            await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => await md.ShowAsync());
        }
 public override async void Execute(object parameter)
 {
     foreach (var item in Locator.MusicLibraryVM.CurrentTrackCollection.SelectedTracks.ToList())
     {
         Locator.MusicLibraryVM.CurrentTrackCollection.Remove(item);
         if (item is TrackItem)
         {
             await MusicLibraryManagement.DeletePlaylistTrack(item as TrackItem, Locator.MusicLibraryVM.CurrentTrackCollection);
         }
     }
     //Locator.MusicLibraryVM.CurrentTrackCollection.SelectedTracks.Clear();
 }
Beispiel #7
0
        private async Task LoadFromDatabase()
        {
            await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                Artists.Clear();
                Tracks.Clear();
            });

            await MusicLibraryManagement.LoadFromSQL();

            await DispatchHelper.InvokeAsync(() =>
            {
                IsMusicLibraryEmpty = !Artists.Any();
                OnPropertyChanged("IsMusicLibraryEmpty");
            });
        }
Beispiel #8
0
        public async Task PerformRoutineCheckIfNotBusy()
        {
            // Routine check to add new files if there are new ones
            if (!IsBusy)
            {
                await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
                {
                    IsBusy = true;
                });

                await MusicLibraryManagement.DoRoutineMusicLibraryCheck();

                await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
                {
                    IsBusy = false;
                });
            }
        }
        public static async Task LoadImageToMemory(ArtistItem item)
        {
            /*
             * Normally, We would need more tight calls to try and make sure that the file
             * exists in our database. However, since this is on the UI thread, we can't do that.
             * Since binding images directly through XAML leads to blocked files when we
             * need to delete them, we have to load them up manually. This should be enough
             * of a check, for now, to make sure images load correctly.
             */
            bool fileExists = item.IsPictureLoaded;

            try
            {
                if (fileExists)
                {
                    var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(item.Picture));

                    using (var stream = await file.OpenAsync(FileAccessMode.Read))
                    {
                        await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                        {
                            var image = new BitmapImage();
                            image.SetSource(stream);
                            item.ArtistImage = image;
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Log("Error getting artist picture : " + item.Name);
            }

            // Failed to get the artist image or no cover image. So go online and check
            // for a new one.
            if (!fileExists)
            {
                await MusicLibraryManagement.FetchArtistPicOrWaitAsync(item);
            }
        }
Beispiel #10
0
        public async Task StartIndexing()
        {
            _artistDatabase.Drop();
            _trackDatabase.Drop();
            _albumDatabase.Drop();

            await DispatchHelper.InvokeAsync(() =>
            {
                Locator.MainVM.InformationText = "Searching for music";
                IsBusy   = true;
                IsLoaded = false;
                OnPropertyChanged("IsBusy");
                OnPropertyChanged("IsLoaded");
            });

            _artistDatabase = new ArtistDatabase();
            _artistDatabase.Initialize();
            _trackDatabase.Initialize();
            _albumDatabase.Initialize();

            await MusicLibraryManagement.DoRoutineMusicLibraryCheck();

            await LoadFromDatabase();

            await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
            {
                IsBusy              = false;
                IsLoaded            = true;
                IsMusicLibraryEmpty = false;
                OnPropertyChanged("Artists");
                OnPropertyChanged("FavoriteAlbums");
                OnPropertyChanged("IsBusy");
                OnPropertyChanged("IsMusicLibraryEmpty");
                OnPropertyChanged("IsLoaded");
                LoadingState = LoadingState.Loaded;
                Locator.MainVM.InformationText = "";
            });

            await GetFavoriteAndRandomAlbums();
        }
        public async Task SetMedia(IVLCMedia media, bool forceVlcLib = false, bool autoPlay = true)
        {
            if (media == null)
            {
                throw new ArgumentNullException("media", "Media parameter is missing. Can't play anything");
            }
            Stop();
            UseVlcLib = true; // forceVlcLib;

            if (media is VideoItem)
            {
                await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    PlayingType = PlayingType.Video;
                    IsStream    = false;
                    Locator.NavigationService.Go(VLCPage.VideoPlayerPage);
                });

                var video = (VideoItem)media;
                await Locator.MediaPlaybackViewModel.InitializePlayback(video, autoPlay);

                if (video.TimeWatched != TimeSpan.FromSeconds(0))
                {
                    await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => Locator.MediaPlaybackViewModel.Time = (Int64)video.TimeWatched.TotalMilliseconds);
                }

                await SetMediaTransportControlsInfo(string.IsNullOrEmpty(video.Name)? "Video" : video.Name);

                UpdateTileHelper.UpdateMediumTileWithVideoInfo();
            }
            else if (media is TrackItem)
            {
                await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    IsStream    = false;
                    PlayingType = PlayingType.Music;
                });

                var         track = (TrackItem)media;
                StorageFile currentTrackFile;
                try
                {
                    currentTrackFile = track.File ?? await StorageFile.GetFileFromPathAsync(track.Path);
                }
                catch (Exception exception)
                {
                    await MusicLibraryManagement.RemoveTrackFromCollectionAndDatabase(track);

                    await Task.Delay(500);

                    if (TrackCollection.CanGoNext)
                    {
                        await PlayNext();
                    }
                    else
                    {
                        await App.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () => Locator.NavigationService.GoBack_Specific());
                    }
                    return;
                }
                await Locator.MediaPlaybackViewModel.InitializePlayback(track, autoPlay);

                if (_playerEngine != PlayerEngine.BackgroundMFPlayer)
                {
                    await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
                    {
                        await Locator.MusicPlayerVM.SetCurrentArtist();
                        await Locator.MusicPlayerVM.SetCurrentAlbum();
                        await Locator.MusicPlayerVM.UpdatePlayingUI();
                        Locator.Slideshow.AddImg(Locator.MusicPlayerVM.CurrentArtist.Picture);
#if WINDOWS_APP
                        await Locator.MusicPlayerVM.UpdateWindows8UI();
                        await Locator.MusicPlayerVM.Scrobble();
#endif
                    });
                }
                ApplicationSettingsHelper.SaveSettingsValue(BackgroundAudioConstants.CurrentTrack, TrackCollection.CurrentTrack);
            }
            else if (media is StreamMedia)
            {
                UseVlcLib = true;
                await App.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    Locator.VideoVm.CurrentVideo = null;
                    Locator.MediaPlaybackViewModel.PlayingType = PlayingType.Video;
                    IsStream = true;
                });

                await Locator.MediaPlaybackViewModel.InitializePlayback(media, autoPlay);
            }
        }
        private async void AddToCollection_Click(object sender, RoutedEventArgs e)
        {
            await MusicLibraryManagement.AddNewPlaylist(playlistName.Text);

            Locator.NavigationService.GoBack_HideFlyout();
        }
 private void AddToPlaylistButton_Click(object sender, RoutedEventArgs e)
 {
     MusicLibraryManagement.AddAlbumToPlaylist(null);
     Locator.NavigationService.GoBack_Specific();
 }
 private async void NewPlaylistButton_Click(object sender, RoutedEventArgs e)
 {
     await MusicLibraryManagement.AddNewPlaylist(playlistName.Text);
 }