import kaaes.spotify.webapi.android.models.Pager; //导入依赖的package包/类
@Nullable
public ArrayList<TrackListData> getTracks(AlbumListData data) throws InterruptedException {
    Pager<TrackSimple> tracks = null;
    for (int i = 0; tracks == null && i < PreferenceUtils.getRetryCount(this); i++) {
        try {
            tracks = spotifyService.getAlbum(data.albumId).tracks;
        } catch (Exception e) {
            e.printStackTrace();
            if (StaticUtils.shouldResendRequest(e)) Thread.sleep(200);
            else break;
        }
    }
    if (tracks == null) return null;

    ArrayList<TrackListData> trackList = new ArrayList<>();
    for (TrackSimple track : tracks.items) {
        trackList.add(new TrackListData(track, data.albumName, data.albumId, data.albumImage, data.albumImageLarge));
    }
    return trackList;
}
 

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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.models.Pager; //导入依赖的package包/类
@Nullable
public Pager<PlaylistSimple> getMyPlaylists() throws InterruptedException {
    Pager<PlaylistSimple> playlists = null;
    for (int i = 0; playlists == null && i < PreferenceUtils.getRetryCount(this); i++) {
        try {
            playlists = spotifyService.getMyPlaylists();
        } catch (Exception e) {
            e.printStackTrace();
            if (StaticUtils.shouldResendRequest(e)) Thread.sleep(200);
            else break;
        }
    }
    return playlists;
}
 

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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.models.Pager; //导入依赖的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);
        }
    }));
}
 

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的package包/类
/**
 * Returns a list of the Spotify artists whose names match a supplied string.
 * @param strSearch the string to match against
 * @return a list of the Spotify artists whose names match the search string
 */
private List<Artist> getSpotifyArtists(String strSearch) {
    try {
        ArtistsPager artistsPager = getSpotifyService().searchArtists(strSearch);
        if (artistsPager != null) {
            Pager<Artist> artistPager = artistsPager.artists;
            if (artistPager != null) {
                return artistPager.items;
            }
        }
    } catch (RetrofitError e) {
        Log.e(LOG_TAG, "RetrofitError while fetching artist list: " + e);
    }
    return null;
}
 

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的package包/类
private void loadAlbums(final int offset) {

        HashMap<String, Object> options = new HashMap<>();
        options.put(SpotifyService.OFFSET, Integer.toString(offset));
        options.put(SpotifyService.LIMIT, Integer.toString(Constants.PAGE_LIMIT));
        options.put(SpotifyService.MARKET, SpotifyTvApplication.getCurrentUserCountry());
        SpotifyTvApplication.getInstance().getSpotifyService().getArtistAlbums(mArtistId, options, new Callback<Pager<Album>>() {
            @Override
            public void success(Pager<Album> albumPager, Response response) {
                for (Album album : albumPager.items) {
                    try {
                        AlbumType albumType = AlbumType.valueOf(album.album_type.toUpperCase());

                        // add to corresponding adapter
                        ArrayObjectAdapter adapter = mAlbumsAdapters.get(albumType);
                        adapter.add(adapter.size(), album);
                    } catch (IllegalArgumentException e) {
                        Log.d(TAG, String.format("Album Type %s is unknown", album.album_type), e);
                    }
                }

                if (albumPager.next != null) {
                    loadAlbums(albumPager.offset + Constants.PAGE_LIMIT);
                }
            }

            @Override
            public void failure(RetrofitError error) {

            }
        });
    }
 

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的package包/类
private void loadMyAlbums(final int offset) {
    if (mMyAlbumsLoading){
        return;
    }

    mMyAlbumsLoading = true;
    Map<String, Object> options = new HashMap<>();
    options.put(SpotifyService.OFFSET, offset);
    options.put(SpotifyService.LIMIT, Constants.PAGE_LIMIT);
    getSpotifyService().getMySavedAlbums(options, new Callback<Pager<SavedAlbum>>() {
        @Override
        public void success(Pager<SavedAlbum> savedAlbumPager, Response response) {
            List<Album> albums = new ArrayList<>(savedAlbumPager.items.size());
            List<ArtistSimple> artists = new ArrayList<>(savedAlbumPager.items.size());

            // keep track of all artists to avoid duplicates
            if (offset == 0) {
                allArtistUris = new ArrayList<>(savedAlbumPager.items.size());
            }

            for (SavedAlbum savedAlbum : savedAlbumPager.items) {
                albums.add(savedAlbum.album);
                for (ArtistSimple artist : savedAlbum.album.artists) {
                    if (!allArtistUris.contains(artist.id)) {
                        artists.add(artist);
                        allArtistUris.add(artist.id);
                    }
                }
            }
            mSavedAlbumsAdapter.addAll(savedAlbumPager.total, mSavedAlbumsAdapter.size(), albums);
            mSavedArtistsAdapter.addAll(mSavedArtistsAdapter.size(), artists);
            mMyAlbumsLoading = false;
        }

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

import kaaes.spotify.webapi.android.models.Pager; //导入依赖的package包/类
public static List<String> getTrackUrisFromTrackPager(Pager<TrackSimple> trackPager) {
    List<String> trackUris = new ArrayList<>(trackPager.items.size());
    for (TrackSimple trackSimple : trackPager.items) {
        trackUris.add(trackSimple.uri);
    }
    return trackUris;
}