예제 #1
0
        public async Task ClearCache()
        {
            CanClearCache = false;
            try
            {
                await Task.Run(() => _coverService.ClearCache());

                CacheSize = Helper.MakeNiceSize(_coverService.CacheSize());
            }
            catch (Exception exc)
            {
                _logger.WarnException("Failed to clear cover cache", exc);
            }
            finally
            {
                CanClearCache = true;
            }
        }
예제 #2
0
        internal async Task UpdateView()
        {
            try
            {
                var tokenPresent = _Settings.SpotifyToken != null;
                if (!tokenPresent)
                {
                    NotifyNotLoggedIn?.Invoke(this, Resources.App_NotLoggedIn);
                }
                var status = _SpotifyController.GetStatus();
                if (status == null)
                {
                    return;
                }

                var track  = status.track?.track_resource?.name;
                var artist = status.track?.artist_resource?.name;
                if (status.track != null)
                {
                    MaxProgress = status.track.length;
                    Progress    = status.playing_position;
                    IsPlaying   = status.playing;
                    Volume      = status.volume;

                    if (IsPlaying)
                    {
                        OnCoverDisplayFadeOut();
                    }

                    HasTrackInformation = !string.IsNullOrEmpty(track) || !string.IsNullOrEmpty(artist);
                    var currentTrack      = string.IsNullOrEmpty(track) ? "-" : track;
                    var currentArtist     = string.IsNullOrEmpty(artist) ? "-" : artist;
                    var trackFriendlyName = string.Format(_songFriendlyNameFormat, currentArtist, currentTrack);

                    TrackUrl          = status.track.track_resource?.location.og;
                    SpotifyUri        = status.track.track_resource?.uri;
                    CurrentTrack      = currentTrack;
                    CurrentArtist     = currentArtist;
                    TrackFriendlyName = trackFriendlyName;
                }
                TrackId = GetTrackId(TrackUrl);

                CanPlayPause    = _SpotifyController.IsSpotifyOpen();
                CanPlayPrevious = _SpotifyController.IsSpotifyOpen();
                CanPlayNext     = _SpotifyController.IsSpotifyOpen();
                CanVolumeDown   = _SpotifyController.IsSpotifyOpen();
                CanVolumeUp     = _SpotifyController.IsSpotifyOpen();

                if (_SpotifyController.IsSpotifyOpen() &&
                    !string.IsNullOrEmpty(track) &&
                    !string.IsNullOrEmpty(artist))
                {
                    if (_Settings.DisableAnimations)
                    {
                        CoverImage = NoCoverUri; //Reset cover image, no cover is better than an old one
                    }
                    try
                    {
                        var coverUri = await _CoverService.FetchCover(status);

                        if (string.IsNullOrEmpty(coverUri))
                        {
                            coverUri = UnknownCoverUri;
                        }
                        CoverImage = coverUri;
                        if (IsPlaying)
                        {
                            OnCoverDisplayFadeIn();
                        }
                    }
                    catch (Exception e)
                    {
                        _Logger.WarnException("Failed to retrieve cover information with: " + e.Message, e);
                    }
                }
                else
                {
                    CoverImage = NoCoverUri;
                    if (IsPlaying)
                    {
                        OnCoverDisplayFadeIn();
                    }
                }


                if (tokenPresent)
                {
                    if (TrackId != null)
                    {
                        IsTrackSaved = (await _SpotifyController.IsTracksSaved(new[] { TrackId })).First();
                    }
                    await UpdatePlaylists().ConfigureAwait(false);
                }
            }
            catch (Exception exc)
            {
                _Logger.FatalException("UpdateView() failed hard with: " + exc.Message, exc);
                _Logger.Fatal(exc.StackTrace);
            }
        }