import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
private void initializePlayer() {
    SharedPreferences prefsAppData = getSharedPreferences(getString(R.string.sharedpreferences_global), Context.MODE_PRIVATE);
    if (prefsAppData.getInt(getString(R.string.responseType), -1) == AuthenticationResponse.Type.TOKEN.ordinal()) {

        Config config = new Config(
                this,
                prefsAppData.getString(getString(R.string.spotifyAccessToken_value), null),
                prefsAppData.getString(getString(R.string.clientId), null)
        );
        spotifyPlayer = Spotify.getPlayer(config, this, new Player.InitializationObserver() {
            @Override
            public void onInitialized(Player player) {
                player.addConnectionStateCallback(MainActivity.connectionStateCallback);
                player.addPlayerNotificationCallback(TracksActivity.this);
            }

            @Override
            public void onError(Throwable throwable) {
                Log.e("PLAYER", "ERROR: " + throwable.getMessage());
            }
        });

    }
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
/***
 * @param context
 * @param token                      : Spotify token needed to use the api
 * @param observer                   : used to know when player is ready
 * @param playerNotificationCallback
 * @param connectionStateCallback
 */
public static void startPlayer(final Context context, String token, final Player.InitializationObserver observer, @Nullable final PlayerNotificationCallback playerNotificationCallback, @Nullable final ConnectionStateCallback connectionStateCallback) {
    SpotifyPlayerManager.context = context;
    Config playerConfig = new Config(context, token, SpotifyManager.API_KEY);
    setConnectionStateCallback(connectionStateCallback);
    setPlayerNotificationCallback(playerNotificationCallback);
    Spotify.getPlayer(playerConfig, context, new Player.InitializationObserver() {
        @Override
        public void onInitialized(Player pl) {
            player = pl;
            if (connectionStateCallback != null)
                player.addConnectionStateCallback(SpotifyManager.connectionStateCallback);
            if (playerNotificationCallback != null)
                player.addPlayerNotificationCallback(SpotifyManager.playerNotificationCallback);
            observer.onInitialized(player);
        }

        @Override
        public void onError(Throwable throwable) {
            Log.e(SpotifyManager.class.getSimpleName(), "Could not initialize player: " + throwable.getMessage());
            observer.onError(throwable);

        }
    });
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
private void playNext() {
    tracklistRepository.getFirstSong(partyTitle)
        .subscribe(song -> {
            spotifyPlayer.playUri(new Player.OperationCallback() {
                @Override
                public void onSuccess() {
                    Log.d(LogTag.LOG_HOST_SERVICE, "Playing next song in tracklist");
                    isTracklistEmpty = false;
                }

                @Override
                public void onError(Error error) {
                    Log.d(LogTag.LOG_HOST_SERVICE, "Failed to play next song in tracklist: " + error.name());
                    sendPlayingStatusBroadcast(false);
                }
            }, song.getSongUri(), 0, 0);
        }, throwable -> {
            Log.d(LogTag.LOG_HOST_SERVICE, "Could not play next song: " + throwable.getMessage());
            sendPlayingStatusBroadcast(false);
            if (throwable instanceof EmptyTracklistException) {
                isTracklistEmpty = true;
            }
        });
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
public void startSpotifySession(final Activity activity, String accessToken, final Runnable onStarted, final Runnable onFailed) {
    // Spotify API
    SpotifyApi api = new SpotifyApi();
    api.setAccessToken(accessToken);
    mSpotifyService = api.getService();

    // Spotify Player Controller
    String clientId = getString(R.string.spotify_client_id);
    Config playerConfig = new Config(this, accessToken, clientId);
    Player player = Spotify.getPlayer(playerConfig, this, null);
    mSpotifyPlayerController = new SpotifyPlayerController(player, mSpotifyService);

    mSpotifyService.getMe(new Callback<UserPrivate>() {
        @Override
        public void success(UserPrivate user, Response response) {
            saveCurrentUser(user);
            activity.runOnUiThread(onStarted);
        }

        @Override
        public void failure(RetrofitError error) {
            activity.runOnUiThread(onFailed);
        }
    });
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的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 com.spotify.sdk.android.player.Player; //导入依赖的package包/类
private void pause() {
    spotifyPlayer.pause(new Player.OperationCallback() {
        @Override
        public void onSuccess() {
            Log.d(LogTag.LOG_HOST_SERVICE, "Paused music successfully");
        }

        @Override
        public void onError(Error error) {
            Log.d(LogTag.LOG_HOST_SERVICE, "Failed to pause music");
        }
    });
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
private void resume() {
    spotifyPlayer.resume(new Player.OperationCallback() {
        @Override
        public void onSuccess() {
            Log.d(LogTag.LOG_HOST_SERVICE, "Resumed music successfully");
        }

        @Override
        public void onError(Error error) {
            Log.d(LogTag.LOG_HOST_SERVICE, "Failed to resume music");
        }
    });
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
public static Player player() {
    return player;
}
 

import com.spotify.sdk.android.player.Player; //导入依赖的package包/类
private Single<Boolean> initPlayer() {
    return Single.create(subscriber -> {

        playerConfig = new Config(SpotiqHostService.this,
            spotifyCommunicatorService.getAuthenticator().getAccessToken(),
            BuildConfig.SPOTIFY_CLIENT_ID);
        playerConfig.useCache(false);

        spotifyPlayer = Spotify.getPlayer(playerConfig, SpotiqHostService.this, new SpotifyPlayer.InitializationObserver() {
            @Override
            public void onInitialized(SpotifyPlayer player) {
                spotifyPlayer.addConnectionStateCallback(SpotiqHostService.this);
                spotifyPlayer.addNotificationCallback(SpotiqHostService.this);
                spotifyPlayer.setPlaybackBitrate(new Player.OperationCallback() {
                    @Override
                    public void onSuccess() {
                        subscriber.onSuccess(true);
                        Log.d(LogTag.LOG_HOST_SERVICE, "Set Spotify Player custom playback bitrate successfully");
                        sendPlayingStatusBroadcast(false); //make sure all listeners are up to sync with an inititally paused status
                        mediaSessionHandler.setSessionActive();
                    }

                    @Override
                    public void onError(Error error) {
                        subscriber.onError(new PlayerInitializationException(error.name()));
                        Log.d(LogTag.LOG_HOST_SERVICE, "Failed to set Spotify Player playback bitrate. Cause: " + error.toString());

                    }
                }, PlaybackBitrate.BITRATE_HIGH);

            }

            @Override
            public void onError(Throwable throwable) {
                subscriber.onError(throwable);
                Log.d(LogTag.LOG_HOST_SERVICE, "Could not initialize Spotify Player: " + throwable.getMessage());
                stopSelf();
            }

        });
    });
}