Beispiel #1
0
        /// <summary>
        /// An item failed to open
        /// </summary>
        /// <param name="item">The item that failed to open</param>
        public void ItemFailedToOpen(MediaPlaybackItem item)
        {
            App.playbackService.RemoveFromQueue(GetMediaItemId(item), localLock);
            playlistMediaIds.RemoveAt(playlistMediaIds.IndexOf(GetMediaItemId(item)));
            long loadingKey = DateTime.Now.Ticks;

            MainPage.AddLoadingLock(loadingKey);
            UpdateFailuresCount(1, loadingKey);
            MainPage.RemoveLoadingLock(loadingKey);
        }
Beispiel #2
0
 /// <summary>
 /// The main constructor
 /// </summary>
 /// <param name="currentLock">The global lock when the session was created, session dies when lock changes</param>
 /// <param name="source">The service to retrieve the song from</param>
 /// <param name="type">What kind of Spotify resource</param>
 /// <param name="shuffle">Whether or not shuffling is enabled for session playback</param>
 /// <param name="tracksHref">The reference to the download location for tracks</param>
 /// <param name="totalTracks">The total number of tracks in the playback session</param>
 public PlaybackSession(long currentLock, PlaybackSource source, PlaybackType type, bool shuffle, string tracksHref, int totalTracks)
 {
     localLock        = currentLock;
     this.source      = source;
     this.type        = type;
     this.shuffling   = shuffle;
     this.tracksHref  = tracksHref;
     this.totalTracks = totalTracks;
     prevRemoteAttempts.Add(0);
     if (App.mainPage != null)
     {
         long loadingKey = DateTime.Now.Ticks;
         MainPage.AddLoadingLock(loadingKey);
         App.mainPage.SetLoadersMessage("", localLock, loadingKey);
         MainPage.RemoveLoadingLock(loadingKey);
     }
 }
Beispiel #3
0
        /// <summary>
        /// Load the range of tracks from the remote playlist in reverse order
        /// </summary>
        /// <param name="start">The start position on remote to download to local, the last position added to the queue</param>
        /// <param name="end">The end position on remote to download to local, the first position added to the queue</param>
        /// <param name="lockOverride">Whether or not to ignore if the lock is set (Used when recursing into itself)</param>
        /// <returns>True a total of end - start tracks are downloaded, false otherwise</returns>
        public async Task <bool> LoadTracksReverse(int start, int end, bool lockOverride)
        {
            long loadingKey = DateTime.Now.Ticks;

            MainPage.AddLoadingLock(loadingKey);
            if (loadLock && !lockOverride)
            {
                return(false);
            }
            loadLock = true;
            int successes = 0;

            if (start < 0)
            {
                start = 0;
            }
            nextRemoteAttempts.Add(end);
            prevRemoteAttempts.Insert(0, start);

            int limit = end - start + 1;

            App.mainPage.SetLoadingProgress(source, 0, limit, localLock, loadingKey);

            if (localLock != App.playbackService.GlobalLock)
            {
                return(false);
            }

            List <Track> tracks = await GetTracksInRange(start, limit);

            if (tracks.Count != limit)
            {
                UpdateFailuresCount(limit - tracks.Count, loadingKey);
            }
            else
            {
                List <KeyValuePair <MediaSource, Track> > sources = new List <KeyValuePair <MediaSource, Track> >();

                if (this.source == PlaybackSource.Spotify)
                {
                    for (int i = 0; i < tracks.Count; i++)
                    {
                        Track track = tracks[i];
                        if (localLock == App.playbackService.GlobalLock)
                        {
                            if (track.previewUrl != "")
                            {
                                sources.Add(new KeyValuePair <MediaSource, Track>(MediaSource.CreateFromUri(new Uri(track.previewUrl)), track));
                            }
                            else
                            {
                                UpdateFailuresCount(1, loadingKey);
                            }
                        }
                        App.mainPage.SetLoadingProgress(source, i + 1 + limit - tracks.Count, limit, localLock, loadingKey);
                    }
                }
                else if (this.source == PlaybackSource.YouTube && localLock == App.playbackService.GlobalLock)
                {
                    for (int i = 0; i < tracks.Count; i++)
                    {
                        Track track = tracks[i];

                        string videoId = "";
                        if (localLock == App.playbackService.GlobalLock)
                        {
                            videoId = await SearchForVideoId(track);
                        }

                        if (localLock == App.playbackService.GlobalLock)
                        {
                            if (videoId == "")
                            {
                                UpdateFailuresCount(1, loadingKey);
                            }
                            else
                            {
                                try
                                {
                                    sources.Add(new KeyValuePair <MediaSource, Track>(await GetAudioAsync(videoId, track.name), track));
                                }
                                catch (Exception)
                                {
                                    UpdateFailuresCount(1, loadingKey);
                                }
                            }
                        }
                        App.mainPage.SetLoadingProgress(PlaybackSource.YouTube, i + 1 + limit - tracks.Count, limit, localLock, loadingKey);
                    }
                }

                for (int i = sources.Count - 1; i >= 0; i--)
                {
                    KeyValuePair <MediaSource, Track> pair = sources[i];
                    if (localLock == App.playbackService.GlobalLock)
                    {
                        MediaPlaybackItem          playbackItem      = new MediaPlaybackItem(pair.Key);
                        MediaItemDisplayProperties displayProperties = playbackItem.GetDisplayProperties();
                        displayProperties.Type = MediaPlaybackType.Music;
                        displayProperties.MusicProperties.Title      = pair.Value.name;
                        displayProperties.MusicProperties.AlbumTitle = pair.Value.album.name;
                        displayProperties.MusicProperties.Artist     = pair.Value.GetMainArtistName();
                        if (pair.Value.album.imageUrl != "")
                        {
                            displayProperties.Thumbnail = RandomAccessStreamReference.CreateFromUri(new Uri(pair.Value.album.imageUrl));
                        }
                        playbackItem.ApplyDisplayProperties(displayProperties);
                        pair.Key.CustomProperties["mediaItemId"] = pair.Value.id;

                        string id = GetMediaItemId(playbackItem);
                        if (!playlistMediaIds.Contains(id))
                        {
                            App.playbackService.AddToBeginningOfQueue(playbackItem, localLock);
                            playlistMediaIds.Insert(0, id);
                            successes++;
                        }
                    }
                }
            }

            MainPage.RemoveLoadingLock(loadingKey);

            if (successes != limit && start > 0)
            {
                return(await LoadTracks(start - limit - (limit - tracks.Count), start + limit, true));
            }
            loadLock = false;
            return(tracks.Count == limit);
        }
Beispiel #4
0
        /// <summary>
        /// Load the range of tracks from the remote playlist
        /// </summary>
        /// <param name="start">The first track to load from remote</param>
        /// <param name="end">The last track to load from remote</param>
        /// <param name="lockOverride">Whether or not to ignore if the lock is set (Used when recursing into itself)</param>
        /// <returns>True a total of end - start tracks are downloaded, false otherwise</returns>
        public async Task <bool> LoadTracks(int start, int end, bool lockOverride)
        {
            long loadingKey = DateTime.Now.Ticks;

            MainPage.AddLoadingLock(loadingKey);
            if (loadLock && !lockOverride)
            {
                return(false);
            }
            loadLock = true;
            int successes = 0;
            int limit;

            if (shuffling)
            {
                if (shufflePositionsAvailable.Count == 0)
                {
                    ReFillShufflePositionsAvailable();
                }
                if (shufflePositionsAvailable.Count < end - start)
                {
                    limit = shufflePositionsAvailable.Count;
                }
                else
                {
                    limit = end - start;
                }
            }
            else
            {
                if (totalTracks > 0 && end >= totalTracks)
                {
                    end = totalTracks - 1;
                }
                nextRemoteAttempts.Insert(0, end);
                if (start == 0)
                {
                    prevRemoteAttempts.Add(start + TRACKS_PER_REQUEST);
                }
                else
                {
                    prevRemoteAttempts.Add(start);
                }

                limit = end - start + 1;
            }

            App.mainPage.SetLoadingProgress(source, 0, limit, localLock, loadingKey);

            if (localLock != App.playbackService.GlobalLock)
            {
                return(false);
            }

            List <Track> tracks = new List <Track>();

            if (shuffling)
            {
                tracks = await GetTracksRandom(limit);
            }
            else
            {
                tracks = await GetTracksInRange(start, limit);
            }

            if (tracks.Count == totalTracks)
            {
                limit = totalTracks;
                App.mainPage.SetLoadingProgress(source, 0, limit, localLock, loadingKey);
            }

            if (tracks.Count != limit)
            {
                UpdateFailuresCount(limit - tracks.Count, loadingKey);
            }

            List <KeyValuePair <MediaSource, Track> > sources = new List <KeyValuePair <MediaSource, Track> >();

            if (source == PlaybackSource.Spotify)
            {
                for (int i = 0; i < tracks.Count; i++)
                {
                    Track track = tracks[i];
                    if (localLock == App.playbackService.GlobalLock)
                    {
                        if (track.previewUrl != "")
                        {
                            sources.Add(new KeyValuePair <MediaSource, Track>(MediaSource.CreateFromUri(new Uri(track.previewUrl)), track));
                        }
                        else
                        {
                            UpdateFailuresCount(1, loadingKey);
                        }
                    }
                    App.mainPage.SetLoadingProgress(source, i + 1 + limit - tracks.Count, limit, localLock, loadingKey);
                }
            }
            else if (source == PlaybackSource.YouTube && localLock == App.playbackService.GlobalLock)
            {
                for (int i = 0; i < tracks.Count; i++)
                {
                    Track track = tracks[i];

                    string videoId = "";
                    if (localLock == App.playbackService.GlobalLock)
                    {
                        videoId = await SearchForVideoId(track);
                    }

                    if (localLock == App.playbackService.GlobalLock)
                    {
                        if (videoId == "")
                        {
                            UpdateFailuresCount(1, loadingKey);
                        }
                        else
                        {
                            try
                            {
                                sources.Add(new KeyValuePair <MediaSource, Track>(await GetAudioAsync(videoId, track.name), track));
                            }
                            catch (Exception)
                            {
                                UpdateFailuresCount(1, loadingKey);
                            }
                        }
                    }
                    App.mainPage.SetLoadingProgress(PlaybackSource.YouTube, i + 1 + limit - tracks.Count, limit, localLock, loadingKey);
                }
            }

            bool firstPlay = false;

            for (int i = 0; i < sources.Count; i++)
            {
                KeyValuePair <MediaSource, Track> pair = sources[i];
                if (localLock == App.playbackService.GlobalLock)
                {
                    MediaPlaybackItem          playbackItem      = new MediaPlaybackItem(pair.Key);
                    MediaItemDisplayProperties displayProperties = playbackItem.GetDisplayProperties();
                    displayProperties.Type = MediaPlaybackType.Music;
                    displayProperties.MusicProperties.Title      = pair.Value.name;
                    displayProperties.MusicProperties.AlbumTitle = pair.Value.album.name;
                    displayProperties.MusicProperties.Artist     = pair.Value.GetMainArtistName();
                    if (pair.Value.album.imageUrl != "")
                    {
                        displayProperties.Thumbnail = RandomAccessStreamReference.CreateFromUri(new Uri(pair.Value.album.imageUrl));
                    }
                    playbackItem.ApplyDisplayProperties(displayProperties);
                    pair.Key.CustomProperties["mediaItemId"] = pair.Value.id;

                    string id = GetMediaItemId(playbackItem);
                    if (!playlistMediaIds.Contains(id))
                    {
                        App.playbackService.AddToQueue(playbackItem, localLock);
                        playlistMediaIds.Add(id);
                        successes++;
                    }

                    if (currentlyPlaying == "")
                    {
                        firstPlay        = true;
                        currentlyPlaying = GetMediaItemId(playbackItem);
                    }
                }
            }

            if (firstPlay)
            {
                App.playbackService.PlayFromBeginning(localLock);
            }

            MainPage.RemoveLoadingLock(loadingKey);

            if (shuffling)
            {
                if (successes != limit && shufflePositionsAvailable.Count > 0)
                {
                    return(await LoadTracks(0, limit - successes, true));
                }
            }
            else
            {
                if (successes != limit && end < totalTracks - 1)
                {
                    return(await LoadTracks(start + limit, start + limit + (limit - tracks.Count), true));
                }
            }

            loadLock = false;
            return(tracks.Count == limit);
        }