import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private Observable<Pager<PlaylistSimple>> getUserPlaylists() {
    return Observable.create(subscriber -> {
        Map<String, Object> searchOptions = new HashMap<>();
        searchOptions.put(SpotifyService.LIMIT, SpotifyConstants.PLAYLIST_SEARCH_QUERY_RESPONSE_LIMIT);
        searchOptions.put(SpotifyService.OFFSET, 0);

        findPlaylistsRecursively(searchOptions)
            .subscribeOn(Schedulers.io())
            .retryWhen(throwable -> throwable.delay(ApplicationConstants.REQUEST_RETRY_DELAY_SEC, TimeUnit.SECONDS))
            .subscribe(playlistPager -> {
                subscriber.onNext(playlistPager);
            }, throwable -> {
                Log.d(LogTag.LOG_SEARCH, "Error when getting playlist data");
            });
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private void loadFeaturedPlaylists() {
    Map<String, Object> options = new HashMap<>();
    options.put(SpotifyService.COUNTRY, SpotifyTvApplication.getCurrentUserCountry());
    options.put("timestamp", DateFormat.format("yyyy-MM-dd'T'hh:mm:ss", new Date()));
    getSpotifyService().getFeaturedPlaylists(options, new Callback<FeaturedPlaylists>() {
        @Override
        public void success(FeaturedPlaylists featuredPlaylists, Response response) {
            mFeaturedPlaylistsAdapter.addAll(0, featuredPlaylists.playlists.items);
        }

        @Override
        public void failure(RetrofitError error) {

        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private void loadPlaylists(int offset) {
    if (mPlaylistsLoading){
        return;
    }

    mPlaylistsLoading = true;
    Map<String, Object> options = new HashMap<>();
    options.put(SpotifyService.OFFSET, offset);
    options.put(SpotifyService.LIMIT, Constants.PAGE_LIMIT);
    getSpotifyService().getMyPlaylists(options, new Callback<Pager<PlaylistSimple>>() {
        @Override
        public void success(Pager<PlaylistSimple> playlistPager, Response response) {
            mPlaylistsAdapter.addAll(playlistPager.total, mPlaylistsAdapter.size(), playlistPager.items);
            mPlaylistsLoading = false;
        }

        @Override
        public void failure(RetrofitError error) {
            mPlaylistsLoading = false;
        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private void loadMySongs(int offset) {
    if (mMySongsLoading){
        return;
    }

    mMySongsLoading = true;
    Map<String, Object> options = new HashMap<>();
    options.put(SpotifyService.OFFSET, offset);
    options.put(SpotifyService.LIMIT, Constants.PAGE_LIMIT);
    getSpotifyService().getMySavedTracks(options, new Callback<Pager<SavedTrack>>() {
        @Override
        public void success(Pager<SavedTrack> savedTrackPager, Response response) {
            List<Track> tracks = new ArrayList<>(savedTrackPager.items.size());
            for (SavedTrack savedTrack : savedTrackPager.items) {
                tracks.add(savedTrack.track);
            }
            mSavedSongsAdapter.addAll(savedTrackPager.total, mSavedSongsAdapter.size(), tracks);
            mMySongsLoading = false;
        }

        @Override
        public void failure(RetrofitError error) {
            mMySongsLoading = false;
        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private static void loadAlbumFromUri(SpotifyService service, String uri, final SpotifyObjectLoaderCallback callback) {
    SpotifyTvApplication.getInstance().getSpotifyService().getAlbum(uri.replace(ALBUM_URI, ""), new Callback<Album>() {
        @Override
        public void success(Album album, Response response) {
            if (callback != null) {
                callback.success(album, response);
            }
        }

        @Override
        public void failure(RetrofitError error) {
            if (callback != null) {
                callback.failure(error);
            }
        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private static void loadArtistFromUri(SpotifyService service, String uri, final SpotifyObjectLoaderCallback callback) {
    SpotifyTvApplication.getInstance().getSpotifyService().getArtist(uri.replace(ARTIST_URI, ""), new Callback<Artist>() {
        @Override
        public void success(Artist artist, Response response) {
            if (callback != null) {
                callback.success(artist, response);
            }
        }

        @Override
        public void failure(RetrofitError error) {
            if (callback != null) {
                callback.failure(error);
            }
        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private static void loadPlaylistFromUri(SpotifyService service, String uri, final SpotifyObjectLoaderCallback callback) {
    String[] uriParts = uri.split(USER_PLAYLIST_URI);
    if (uriParts.length == 2) {
        String userId = uriParts[0].replace(USER_URI, "");
        String playlistId = uriParts[1];
        SpotifyTvApplication.getInstance().getSpotifyService().getPlaylist(userId, playlistId, new Callback<Playlist>() {
            @Override
            public void success(Playlist playlist, Response response) {
                if (callback != null) {
                    callback.success(playlist, response);
                }
            }

            @Override
            public void failure(RetrofitError error) {
                if (callback != null) {
                    callback.failure(error);
                }
            }
        });
    }
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private static void loadTrackFromUri(SpotifyService service, String uri, final SpotifyObjectLoaderCallback callback) {
    SpotifyTvApplication.getInstance().getSpotifyService().getTrack(uri.replace(TRACK_URI, ""), new Callback<Track>() {
        @Override
        public void success(Track track, Response response) {
            if (callback != null) {
                callback.success(track, response);
            }
        }

        @Override
        public void failure(RetrofitError error) {
            if (callback != null) {
                callback.failure(error);
            }
        }
    });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
public SpotifyPlayerController(Player player, SpotifyService spotifyService) {
    context = SpotifyTvApplication.getInstance().getApplicationContext();
    mHandler = new Handler(context.getMainLooper());
    mUserPreferences = UserPreferences.getInstance(context);

    audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
    mPlayer = player;

    mPlayer.addPlayerNotificationCallback(this);
    mPlayer.addConnectionStateCallback(this);
    setPlayerBitrate(mUserPreferences.getBitrate());
    setShuffle(mUserPreferences.getShuffle());

    mediaSessionController = new MediaPlayerSessionController(context, this);

    mSpotifyService = spotifyService;

    // init playing state with dummy data
    resetPlayingState();
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
@Override
protected AsyncTaskResult<List<Track>> doInBackground(Artist... params) {
    try {
        Map<String, Object> options = new HashMap<>();
        options.put(SpotifyService.COUNTRY, Locale.getDefault().getCountry());
        Tracks artistTopTracks = new SpotifyApi().getService().getArtistTopTrack(params[0].getId(), options);

        List<Track> trackList = new ArrayList<>();
        for(kaaes.spotify.webapi.android.models.Track track : artistTopTracks.tracks) {
            trackList.add(new Track(track));
        }

        return new AsyncTaskResult<>(trackList);

    } catch (RetrofitError error) {
        if(error.getResponse() == null) {
            return new AsyncTaskResult<>(new NotFoundException());
        } else {
            switch(error.getResponse().getStatus()) {
                case HttpURLConnection.HTTP_BAD_REQUEST:
                    return new AsyncTaskResult<>(new BadRequestException());
                case HttpURLConnection.HTTP_NOT_FOUND:
                    return new AsyncTaskResult<>(new NotFoundException());
                default:
                    return new AsyncTaskResult<>(error);
            }
        }
    }
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedState) {
    super.onCreate(savedState);

    songPreviewPlayer = new PreviewPlayer();

    //load user data and user search suggestions
    restartableLatestCache(LOAD_USER_RESTARTABLE_ID,
        () -> spotifyRepository.getMe(spotifyCommunicatorService.getWebApi())
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .retryWhen(throwable -> throwable.delay(ApplicationConstants.REQUEST_RETRY_DELAY_SEC, TimeUnit.SECONDS)),
        (songSearchView, userPrivate) -> {
            user = new User(userPrivate.id, userPrivate.display_name, userPrivate.images);
            //load personalized search suggestions
            Map<String, Object> searchOptions = new HashMap<>();
            searchOptions.put(SpotifyService.LIMIT, SpotifyConstants.TOP_TRACKS_QUERY_RESPONSE_LIMIT);
            searchOptions.put(SpotifyService.TIME_RANGE, SpotifyConstants.TIME_RANGE_SHORT);
            spotifyRepository.getMyTopTracks(searchOptions, spotifyCommunicatorService.getWebApi())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .retryWhen(throwable -> throwable.delay(ApplicationConstants.REQUEST_RETRY_DELAY_SEC, TimeUnit.SECONDS))
                .subscribe(tracks -> {
                    List<Song> songSuggestions = TrackMapper.tracksToSongs(tracks, user);
                    SongSearchSuggestionsBuilder suggestionsBuilder =
                        new SongSearchSuggestionsBuilder(songSuggestions, ApplicationConstants.MAX_SONG_SUGGESTIONS);
                    songSearchView.updateSearchSuggestions(suggestionsBuilder);
                });
        },
        (songSearchView, throwable) -> {
            Log.d(LogTag.LOG_SEARCH, "Error when getting user Spotify data");
        });

    if (savedState == null) {
        start(LOAD_USER_RESTARTABLE_ID);
    }
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
void searchTracks(String query) {
    Map<String, Object> searchOptions = new HashMap<>();
    searchOptions.put(SpotifyService.LIMIT, SpotifyConstants.TRACK_SEARCH_QUERY_RESPONSE_LIMIT);
    searchOptions.put(SpotifyService.OFFSET, 0);

    partiesRepository.getParty(partyTitle)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(partySnapshot -> {
            Party dbParty = partySnapshot.child(FirebaseConstants.CHILD_PARTYINFO).getValue(Party.class);
            searchOptions.put(SpotifyService.MARKET, dbParty.getHostMarket());

            searchTracksRecursively(query, searchOptions)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(tracksPager -> TrackMapper.tracksToSongs(tracksPager.tracks.items, user))
                .subscribe(songs -> {
                    if (getView() != null) {
                        if (songs.isEmpty()) getView().showMessage("No songs were found for the search query " + query);
                        getView().updateSearch(songs);
                    }
                }, throwable -> {
                    Log.d(LogTag.LOG_SEARCH, "Something went wrong on searching for tracks");
                    throwable.printStackTrace();
                });
        });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private Observable<TracksPager> searchTracksRecursively(String query, Map<String, Object> searchOptions) {
    int lastOffset = (int) searchOptions.get(SpotifyService.OFFSET);
    return spotifyRepository.searchTracks(query, searchOptions, spotifyCommunicatorService.getWebApi())
        .concatMap(tracksPager -> {
            if (lastOffset + tracksPager.tracks.limit >= SpotifyConstants.TRACK_SEARCH_TOTAL_ITEMS_LIMIT
                || lastOffset + tracksPager.tracks.limit >= tracksPager.tracks.total) {
                return Observable.just(tracksPager);
            }
            else {
                searchOptions.put(SpotifyService.OFFSET, lastOffset + tracksPager.tracks.limit);
                return Observable.just(tracksPager).concatWith(searchTracksRecursively(query, searchOptions));
            }
        })
        .doOnError(throwable -> Log.d(LogTag.LOG_SEARCH, "Something went wrong on tracks search recursion: " + throwable.getMessage()));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
void loadPlaylistSongs(PlaylistSimple playlist) {
    Map<String, Object> searchOptions = new HashMap<>();
    searchOptions.put(SpotifyService.LIMIT, SpotifyConstants.PLAYLIST_TRACK_SEARCH_QUERY_RESPONSE_LIMIT);
    searchOptions.put(SpotifyService.OFFSET, 0);

    partiesRepository.getParty(partyTitle)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(partySnapshot -> {
            Party dbParty = partySnapshot.child(FirebaseConstants.CHILD_PARTYINFO).getValue(Party.class);
            searchOptions.put(SpotifyService.MARKET, dbParty.getHostMarket());

            findPlaylistTracksRecursively(playlist, searchOptions)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                //filter out local and unplayable tracks
                .map(playlistPager -> {
                    List<PlaylistTrack> filteredTracks = new ArrayList<>();
                    filteredTracks.addAll(playlistPager.items);
                    for (PlaylistTrack playlistTrack : playlistPager.items) {
                        if (playlistTrack.is_local || !playlistTrack.track.is_playable) {
                            filteredTracks.remove(playlistTrack);
                        }
                    }
                    return filteredTracks;
                })
                .map(filteredTracks -> TrackMapper.playlistTracksToSongs(filteredTracks, user))
                .subscribe(songs -> {
                    if (getView() != null) {
                        if (songs.isEmpty()) getView().showMessage("Playlist is empty");
                        getView().updateSongs(songs);
                    }
                }, throwable -> {
                    Log.d(LogTag.LOG_SEARCH, "Something went wrong on loading playlist songs");
                    throwable.printStackTrace();
                });
        });
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private Observable<Pager<PlaylistSimple>> findPlaylistsRecursively(Map<String, Object> searchOptions) {
    int lastOffset = (int) searchOptions.get(SpotifyService.OFFSET);
    return spotifyRepository.getMyPlaylists(searchOptions, spotifyCommunicatorService.getWebApi())
        .concatMap(playlistPager -> {
            if (lastOffset + playlistPager.limit >= SpotifyConstants.PLAYLIST_SEARCH_TOTAL_ITEMS_LIMIT
                || lastOffset + playlistPager.limit >= playlistPager.total) {
                return Observable.just(playlistPager);
            }
            else {
                searchOptions.put(SpotifyService.OFFSET, lastOffset + playlistPager.limit);
                return Observable.just(playlistPager).concatWith(findPlaylistsRecursively(searchOptions));
            }
        })
        .doOnError(throwable -> Log.d(LogTag.LOG_SEARCH, "Something went wrong on playlist recursion: " + throwable.getMessage()));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
private Observable<Pager<PlaylistTrack>> findPlaylistTracksRecursively(PlaylistSimple playlist, Map<String, Object> searchOptions) {
    int lastOffset = (int) searchOptions.get(SpotifyService.OFFSET);
    return spotifyRepository.getPlaylistTracks(playlist.owner.id, playlist.id, searchOptions, spotifyCommunicatorService.getWebApi())
        .concatMap(playlistPager -> {
            if (lastOffset + playlistPager.limit >= SpotifyConstants.PLAYLIST_TRACK_SEARCH_TOTAL_ITEMS_LIMIT
                || lastOffset + playlistPager.limit >= playlistPager.total) {
                return Observable.just(playlistPager);
            }
            else {
                searchOptions.put(SpotifyService.OFFSET, lastOffset + playlistPager.limit);
                return Observable.just(playlistPager).concatWith(findPlaylistTracksRecursively(playlist, searchOptions));
            }
        })
        .doOnError(throwable -> Log.d(LogTag.LOG_SEARCH, "Something went wrong on playlist tracks recursion: " + throwable.getMessage()));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
public Observable<UserPrivate> getMe(SpotifyService spotifyService) {
    return Observable.create(subscriber -> spotifyService.getMe(new Callback<UserPrivate>() {
        @Override
        public void success(UserPrivate userPrivate, Response response) {
            subscriber.onNext(userPrivate);
            subscriber.onComplete();
        }

        @Override
        public void failure(RetrofitError error) {
            subscriber.onError(error);
        }
    }));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
public Observable<List<Track>> getMyTopTracks(Map<String, Object> searchOptions, SpotifyService spotifyService) {
    return Observable.create(subscriber -> spotifyService.getTopTracks(searchOptions, new Callback<Pager<Track>>() {
        @Override
        public void success(Pager<Track> trackPager, Response response) {
            subscriber.onNext(trackPager.items);
            subscriber.onComplete();
        }

        @Override
        public void failure(RetrofitError error) {
            subscriber.onError(error);
        }
    }));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
public Observable<Pager<PlaylistSimple>> getMyPlaylists(Map<String, Object> searchOptions, SpotifyService spotifyService) {
    return Observable.create(subscriber -> spotifyService.getMyPlaylists(searchOptions, new Callback<Pager<PlaylistSimple>>() {
        @Override
        public void success(Pager<PlaylistSimple> playlistSimplePager, Response response) {
            subscriber.onNext(playlistSimplePager);
            subscriber.onComplete();
        }

        @Override
        public void failure(RetrofitError error) {
            subscriber.onError(error);
        }
    }));
}
 

import kaaes.spotify.webapi.android.SpotifyService; //导入依赖的package包/类
public Observable<Pager<PlaylistTrack>> getPlaylistTracks(String userId, String playlistId, Map<String, Object> searchOptions, SpotifyService spotifyService) {
    return Observable.create(subscriber -> spotifyService.getPlaylistTracks(userId, playlistId, searchOptions, new Callback<Pager<PlaylistTrack>>() {
        @Override
        public void success(Pager<PlaylistTrack> playlistTrackPager, Response response) {
            subscriber.onNext(playlistTrackPager);
            subscriber.onComplete();
        }

        @Override
        public void failure(RetrofitError error) {
            subscriber.onError(error);
        }
    }));
}