示例#1
0
        public async static Task PlayMusic(AudioFile audioFile, int typePlay, PlaylistFile playlistPlay = null)
        {
            if (StaticContent.Config.StreamMusic)
            {
                await MusicX.Core.VKontakte.Music.Library.StreamToStatus(audioFile.Id, audioFile.OwnerId);
            }
            try
            {
                //type play:
                //1 - проигрования из списка треков
                //2 - проигрование трека из плейлиста
                StaticContent.AudioService.Seek(TimeSpan.Zero);
                var playlistNowPlay = new PlaylistFile()
                {
                    Artist      = "Music X",
                    Cover       = "ms-appx:///Assets/Images/now.png",
                    Id          = 1000,
                    Name        = "Сейчас играет",
                    TracksFiles = new List <AudioFile>(),
                    IsLocal     = false
                };


                if (typePlay == 1)
                {
                    foreach (var trackMusic in StaticContent.MusicVKontakte)
                    {
                        playlistNowPlay.TracksFiles.Add(trackMusic);
                    }
                    var index = playlistNowPlay.TracksFiles.IndexOf(playlistNowPlay.TracksFiles.Single(t => t.Id == audioFile.Id));

                    if (index != 0)
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist(), false);
                        StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
                    }
                    else
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist(), true);
                        StaticContent.AudioService.SwitchNext();
                    }

                    StaticContent.NowPlayPlaylist = playlistNowPlay;
                }
                else if (typePlay == 2)
                {
                    StaticContent.NowPlayPlaylist = playlistPlay;
                    playlistNowPlay.TracksFiles   = playlistPlay.TracksFiles;
                    playlistNowPlay.Tracks        = playlistPlay.Tracks;

                    var index = playlistPlay.TracksFiles.IndexOf(playlistPlay.TracksFiles.Single(t => t.Id == audioFile.Id));

                    if (index != 0)
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), false);
                        StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
                    }
                    else
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), true);
                        StaticContent.AudioService.SwitchNext();
                    }
                }

                if (!(StaticContent.PlaylistsVKontakte.Any(p => p.Id == 1000)))
                {
                    StaticContent.PlaylistsVKontakte.Insert(0, playlistNowPlay);
                }
            }catch (Flurl.Http.FlurlHttpException)
            {
                InternetService.GoToOfflineMode();
            } catch (HttpRequestException)
            {
                InternetService.GoToOfflineMode();
            }catch (Exception e)
            {
                await ContentDialogService.Show(new ExceptionDialog("Ошибка при воспроизведении трека", "Произошла неизвестная ошибка.", e));
            }
        }
        public async static Task PlayMusicForLibrary(AudioFile audioFile, int typePlay, PlaylistFile playlistPlay = null)
        {
            try
            {
                if (audioFile == null)
                {
                    return;
                }
                //type play:
                //1 - проигрования из списка треков
                //2 - проигрование трека по клику на него
                //3 - проигрование трека из плейлиста
                StaticContent.AudioService.Seek(TimeSpan.Zero);

                var lastPlayPlaylist = await PlaylistsService.GetById(1);

                if (audioFile.Source == null)
                {
                    audioFile.Source = await StorageFile.GetFileFromPathAsync(audioFile.SourceString);
                }
                if (!(lastPlayPlaylist.TracksFiles.Any(t => t.SourceString == audioFile.SourceString)))
                {
                    lastPlayPlaylist.TracksFiles.Add(audioFile);
                    await PlaylistsService.SavePlaylist(lastPlayPlaylist);
                }


                var playlistNowPlay = new PlaylistFile()
                {
                    Artist      = "Music X",
                    Cover       = "ms-appx:///Assets/Images/now.png",
                    Id          = 1000,
                    Name        = "Сейчас играет",
                    TracksFiles = new List <AudioFile>(),
                    IsLocal     = true
                };

                if (typePlay == 1)
                {
                    foreach (var trackMusic in StaticContent.Music)
                    {
                        playlistNowPlay.TracksFiles.Add(trackMusic);
                    }
                    StaticContent.NowPlayPlaylist = playlistNowPlay;
                    StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist(), false);
                    StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
                }
                else if (typePlay == 2)
                {
                    StaticContent.NowPlayPlaylist = playlistNowPlay;
                    StaticContent.NowPlayPlaylist.TracksFiles.Add(audioFile);
                    StaticContent.AudioService.SetCurrentPlaylist(playlistNowPlay.ToAudioPlaylist());
                }
                else if (typePlay == 3)
                {
                    StaticContent.NowPlayPlaylist = playlistPlay;

                    var index = 0;
                    try
                    {
                        index = playlistPlay.Tracks.IndexOf(playlistPlay.Tracks.Single(t => t.Id == audioFile.Id));
                    }catch
                    {
                        index = playlistPlay.TracksFiles.IndexOf(playlistPlay.TracksFiles.Single(t => t.Id == audioFile.Id));
                    }

                    if (index != 0)
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), false);
                        StaticContent.AudioService.CurrentPlaylist.CurrentItem = audioFile;
                    }
                    else
                    {
                        StaticContent.AudioService.SetCurrentPlaylist(playlistPlay.ToAudioPlaylist(), true);
                    }
                }

                if (!(StaticContent.Playlists.Any(p => p.Id == 1000)))
                {
                    StaticContent.Playlists.Insert(0, StaticContent.NowPlayPlaylist);
                }
            }catch (Exception e)
            {
                await ContentDialogService.Show(new ExceptionDialog("Невозможно возпроизвести трек.", "Возможно, файл не поддерживается или поврежден.", e));
            }
        }