/*
 * Copyright 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package androidx.media;

import static androidx.media.MediaConstants2.ARGUMENT_ALLOWED_COMMANDS;
import static androidx.media.MediaConstants2.ARGUMENT_ARGUMENTS;
import static androidx.media.MediaConstants2.ARGUMENT_BUFFERING_STATE;
import static androidx.media.MediaConstants2.ARGUMENT_COMMAND_BUTTONS;
import static androidx.media.MediaConstants2.ARGUMENT_COMMAND_CODE;
import static androidx.media.MediaConstants2.ARGUMENT_CUSTOM_COMMAND;
import static androidx.media.MediaConstants2.ARGUMENT_ERROR_CODE;
import static androidx.media.MediaConstants2.ARGUMENT_EXTRAS;
import static androidx.media.MediaConstants2.ARGUMENT_ICONTROLLER_CALLBACK;
import static androidx.media.MediaConstants2.ARGUMENT_MEDIA_ID;
import static androidx.media.MediaConstants2.ARGUMENT_MEDIA_ITEM;
import static androidx.media.MediaConstants2.ARGUMENT_PACKAGE_NAME;
import static androidx.media.MediaConstants2.ARGUMENT_PID;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYBACK_INFO;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYBACK_SPEED;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYBACK_STATE_COMPAT;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYER_STATE;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYLIST;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYLIST_INDEX;
import static androidx.media.MediaConstants2.ARGUMENT_PLAYLIST_METADATA;
import static androidx.media.MediaConstants2.ARGUMENT_QUERY;
import static androidx.media.MediaConstants2.ARGUMENT_RATING;
import static androidx.media.MediaConstants2.ARGUMENT_REPEAT_MODE;
import static androidx.media.MediaConstants2.ARGUMENT_RESULT_RECEIVER;
import static androidx.media.MediaConstants2.ARGUMENT_ROUTE_BUNDLE;
import static androidx.media.MediaConstants2.ARGUMENT_SEEK_POSITION;
import static androidx.media.MediaConstants2.ARGUMENT_SHUFFLE_MODE;
import static androidx.media.MediaConstants2.ARGUMENT_UID;
import static androidx.media.MediaConstants2.ARGUMENT_URI;
import static androidx.media.MediaConstants2.ARGUMENT_VOLUME;
import static androidx.media.MediaConstants2.ARGUMENT_VOLUME_DIRECTION;
import static androidx.media.MediaConstants2.ARGUMENT_VOLUME_FLAGS;
import static androidx.media.MediaConstants2.CONNECT_RESULT_CONNECTED;
import static androidx.media.MediaConstants2.CONNECT_RESULT_DISCONNECTED;
import static androidx.media.MediaConstants2.CONTROLLER_COMMAND_BY_COMMAND_CODE;
import static androidx.media.MediaConstants2.CONTROLLER_COMMAND_BY_CUSTOM_COMMAND;
import static androidx.media.MediaConstants2.CONTROLLER_COMMAND_CONNECT;
import static androidx.media.MediaConstants2.CONTROLLER_COMMAND_DISCONNECT;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_ALLOWED_COMMANDS_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_BUFFERING_STATE_CHAGNED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_CURRENT_MEDIA_ITEM_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_ERROR;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_PLAYBACK_INFO_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_PLAYBACK_SPEED_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_PLAYER_STATE_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_PLAYLIST_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_PLAYLIST_METADATA_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_REPEAT_MODE_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_ROUTES_INFO_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_ON_SHUFFLE_MODE_CHANGED;
import static androidx.media.MediaConstants2.SESSION_EVENT_SEND_CUSTOM_COMMAND;
import static androidx.media.MediaConstants2.SESSION_EVENT_SET_CUSTOM_LAYOUT;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_PAUSE;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_PLAY;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_PREPARE;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_RESET;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_SEEK_TO;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYBACK_SET_SPEED;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_ADD_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_GET_CURRENT_MEDIA_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_GET_LIST;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_REMOVE_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_REPLACE_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SET_LIST;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SET_LIST_METADATA;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SET_REPEAT_MODE;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SET_SHUFFLE_MODE;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SKIP_TO_NEXT_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SKIP_TO_PLAYLIST_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_PLAYLIST_SKIP_TO_PREV_ITEM;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_FAST_FORWARD;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PLAY_FROM_MEDIA_ID;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PLAY_FROM_SEARCH;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PLAY_FROM_URI;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PREPARE_FROM_MEDIA_ID;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PREPARE_FROM_SEARCH;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_PREPARE_FROM_URI;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_REWIND;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_SELECT_ROUTE;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_SET_RATING;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_SUBSCRIBE_ROUTES_INFO;
import static androidx.media.SessionCommand2.COMMAND_CODE_SESSION_UNSUBSCRIBE_ROUTES_INFO;
import static androidx.media.SessionCommand2.COMMAND_CODE_VOLUME_ADJUST_VOLUME;
import static androidx.media.SessionCommand2.COMMAND_CODE_VOLUME_SET_VOLUME;

import android.annotation.TargetApi;
import android.content.Context;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.DeadObjectException;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ResultReceiver;
import android.support.v4.media.session.IMediaControllerCallback;
import android.support.v4.media.session.MediaSessionCompat;
import android.util.ArrayMap;
import android.util.Log;
import android.util.SparseArray;

import androidx.annotation.GuardedBy;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.media.MediaController2.PlaybackInfo;
import androidx.media.MediaSession2.CommandButton;
import androidx.media.MediaSession2.ControllerInfo;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@TargetApi(Build.VERSION_CODES.KITKAT)
class MediaSession2StubImplBase extends MediaSessionCompat.Callback {

    private static final String TAG = "MS2StubImplBase";
    private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);

    private static final SparseArray<SessionCommand2> sCommandsForOnCommandRequest =
            new SparseArray<>();

    static {
        SessionCommandGroup2 group = new SessionCommandGroup2();
        group.addAllPlaybackCommands();
        group.addAllPlaylistCommands();
        group.addAllVolumeCommands();
        Set<SessionCommand2> commands = group.getCommands();
        for (SessionCommand2 command : commands) {
            sCommandsForOnCommandRequest.append(command.getCommandCode(), command);
        }
    }

    private final Object mLock = new Object();

    final MediaSession2.SupportLibraryImpl mSession;
    final Context mContext;

    @GuardedBy("mLock")
    private final ArrayMap<IBinder, ControllerInfo> mControllers = new ArrayMap<>();
    @GuardedBy("mLock")
    private final Set<IBinder> mConnectingControllers = new HashSet<>();
    @GuardedBy("mLock")
    private final ArrayMap<ControllerInfo, SessionCommandGroup2> mAllowedCommandGroupMap =
            new ArrayMap<>();

    MediaSession2StubImplBase(MediaSession2.SupportLibraryImpl session) {
        mSession = session;
        mContext = mSession.getContext();
    }

    @Override
    public void onPrepare() {
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.prepare();
            }
        });
    }

    @Override
    public void onPlay() {
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.play();
            }
        });
    }

    @Override
    public void onPause() {
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.pause();
            }
        });
    }

    @Override
    public void onStop() {
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.reset();
            }
        });
    }

    @Override
    public void onSeekTo(final long pos) {
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.seekTo(pos);
            }
        });
    }

    @Override
    public void onCommand(String command, final Bundle extras, final ResultReceiver cb) {
        switch (command) {
            case CONTROLLER_COMMAND_CONNECT:
                connect(extras, cb);
                break;
            case CONTROLLER_COMMAND_DISCONNECT:
                disconnect(extras);
                break;
            case CONTROLLER_COMMAND_BY_COMMAND_CODE: {
                final int commandCode = extras.getInt(ARGUMENT_COMMAND_CODE);
                IMediaControllerCallback caller =
                        (IMediaControllerCallback) extras.getBinder(ARGUMENT_ICONTROLLER_CALLBACK);
                if (caller == null) {
                    return;
                }

                onCommand2(caller.asBinder(), commandCode, new Session2Runnable() {
                    @Override
                    public void run(ControllerInfo controller) {
                        switch (commandCode) {
                            case COMMAND_CODE_PLAYBACK_PLAY:
                                mSession.play();
                                break;
                            case COMMAND_CODE_PLAYBACK_PAUSE:
                                mSession.pause();
                                break;
                            case COMMAND_CODE_PLAYBACK_RESET:
                                mSession.reset();
                                break;
                            case COMMAND_CODE_PLAYBACK_PREPARE:
                                mSession.prepare();
                                break;
                            case COMMAND_CODE_PLAYBACK_SEEK_TO: {
                                long seekPos = extras.getLong(ARGUMENT_SEEK_POSITION);
                                mSession.seekTo(seekPos);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SET_REPEAT_MODE: {
                                int repeatMode = extras.getInt(ARGUMENT_REPEAT_MODE);
                                mSession.setRepeatMode(repeatMode);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SET_SHUFFLE_MODE: {
                                int shuffleMode = extras.getInt(ARGUMENT_SHUFFLE_MODE);
                                mSession.setShuffleMode(shuffleMode);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SET_LIST: {
                                List<MediaItem2> list = MediaUtils2.fromMediaItem2ParcelableArray(
                                        extras.getParcelableArray(ARGUMENT_PLAYLIST));
                                MediaMetadata2 metadata = MediaMetadata2.fromBundle(
                                        extras.getBundle(ARGUMENT_PLAYLIST_METADATA));
                                mSession.setPlaylist(list, metadata);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SET_LIST_METADATA: {
                                MediaMetadata2 metadata = MediaMetadata2.fromBundle(
                                        extras.getBundle(ARGUMENT_PLAYLIST_METADATA));
                                mSession.updatePlaylistMetadata(metadata);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_ADD_ITEM: {
                                int index = extras.getInt(ARGUMENT_PLAYLIST_INDEX);
                                MediaItem2 item = MediaItem2.fromBundle(
                                        extras.getBundle(ARGUMENT_MEDIA_ITEM));
                                mSession.addPlaylistItem(index, item);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_REMOVE_ITEM: {
                                MediaItem2 item = MediaItem2.fromBundle(
                                        extras.getBundle(ARGUMENT_MEDIA_ITEM));
                                mSession.removePlaylistItem(item);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_REPLACE_ITEM: {
                                int index = extras.getInt(ARGUMENT_PLAYLIST_INDEX);
                                MediaItem2 item = MediaItem2.fromBundle(
                                        extras.getBundle(ARGUMENT_MEDIA_ITEM));
                                mSession.replacePlaylistItem(index, item);
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SKIP_TO_NEXT_ITEM: {
                                mSession.skipToNextItem();
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SKIP_TO_PREV_ITEM: {
                                mSession.skipToPreviousItem();
                                break;
                            }
                            case COMMAND_CODE_PLAYLIST_SKIP_TO_PLAYLIST_ITEM: {
                                MediaItem2 item = MediaItem2.fromBundle(
                                        extras.getBundle(ARGUMENT_MEDIA_ITEM));
                                mSession.skipToPlaylistItem(item);
                                break;
                            }
                            case COMMAND_CODE_VOLUME_SET_VOLUME: {
                                int value = extras.getInt(ARGUMENT_VOLUME);
                                int flags = extras.getInt(ARGUMENT_VOLUME_FLAGS);
                                VolumeProviderCompat vp = mSession.getVolumeProvider();
                                if (vp == null) {
                                    // TODO: Revisit
                                } else {
                                    vp.onSetVolumeTo(value);
                                }
                                break;
                            }
                            case COMMAND_CODE_VOLUME_ADJUST_VOLUME: {
                                int direction = extras.getInt(ARGUMENT_VOLUME_DIRECTION);
                                int flags = extras.getInt(ARGUMENT_VOLUME_FLAGS);
                                VolumeProviderCompat vp = mSession.getVolumeProvider();
                                if (vp == null) {
                                    // TODO: Revisit
                                } else {
                                    vp.onAdjustVolume(direction);
                                }
                                break;
                            }
                            case COMMAND_CODE_SESSION_REWIND: {
                                mSession.getCallback().onRewind(
                                        mSession.getInstance(), controller);
                                break;
                            }
                            case COMMAND_CODE_SESSION_FAST_FORWARD: {
                                mSession.getCallback().onFastForward(
                                        mSession.getInstance(), controller);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PLAY_FROM_MEDIA_ID: {
                                String mediaId = extras.getString(ARGUMENT_MEDIA_ID);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPlayFromMediaId(
                                        mSession.getInstance(), controller, mediaId, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PLAY_FROM_SEARCH: {
                                String query = extras.getString(ARGUMENT_QUERY);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPlayFromSearch(
                                        mSession.getInstance(), controller, query, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PLAY_FROM_URI: {
                                Uri uri = extras.getParcelable(ARGUMENT_URI);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPlayFromUri(
                                        mSession.getInstance(), controller, uri, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PREPARE_FROM_MEDIA_ID: {
                                String mediaId = extras.getString(ARGUMENT_MEDIA_ID);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPrepareFromMediaId(
                                        mSession.getInstance(), controller, mediaId, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PREPARE_FROM_SEARCH: {
                                String query = extras.getString(ARGUMENT_QUERY);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPrepareFromSearch(
                                        mSession.getInstance(), controller, query, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_PREPARE_FROM_URI: {
                                Uri uri = extras.getParcelable(ARGUMENT_URI);
                                Bundle extra = extras.getBundle(ARGUMENT_EXTRAS);
                                mSession.getCallback().onPrepareFromUri(
                                        mSession.getInstance(), controller, uri, extra);
                                break;
                            }
                            case COMMAND_CODE_SESSION_SET_RATING: {
                                String mediaId = extras.getString(ARGUMENT_MEDIA_ID);
                                Rating2 rating = Rating2.fromBundle(
                                        extras.getBundle(ARGUMENT_RATING));
                                mSession.getCallback().onSetRating(
                                        mSession.getInstance(), controller, mediaId, rating);
                                break;
                            }
                            case COMMAND_CODE_SESSION_SUBSCRIBE_ROUTES_INFO: {
                                mSession.getCallback().onSubscribeRoutesInfo(
                                        mSession.getInstance(), controller);
                                break;
                            }
                            case COMMAND_CODE_SESSION_UNSUBSCRIBE_ROUTES_INFO: {
                                mSession.getCallback().onUnsubscribeRoutesInfo(
                                        mSession.getInstance(), controller);
                                break;
                            }
                            case COMMAND_CODE_SESSION_SELECT_ROUTE: {
                                Bundle route = extras.getBundle(ARGUMENT_ROUTE_BUNDLE);
                                mSession.getCallback().onSelectRoute(
                                        mSession.getInstance(), controller, route);
                                break;
                            }
                            case COMMAND_CODE_PLAYBACK_SET_SPEED: {
                                float speed = extras.getFloat(ARGUMENT_PLAYBACK_SPEED);
                                mSession.setPlaybackSpeed(speed);
                                break;
                            }
                        }
                    }
                });
                break;
            }
            case CONTROLLER_COMMAND_BY_CUSTOM_COMMAND: {
                final SessionCommand2 customCommand =
                        SessionCommand2.fromBundle(extras.getBundle(ARGUMENT_CUSTOM_COMMAND));
                IMediaControllerCallback caller =
                        (IMediaControllerCallback) extras.getBinder(ARGUMENT_ICONTROLLER_CALLBACK);
                if (caller == null || customCommand == null) {
                    return;
                }

                final Bundle args = extras.getBundle(ARGUMENT_ARGUMENTS);
                onCommand2(caller.asBinder(), customCommand, new Session2Runnable() {
                    @Override
                    public void run(ControllerInfo controller) throws RemoteException {
                        mSession.getCallback().onCustomCommand(
                                mSession.getInstance(), controller, customCommand, args, cb);
                    }
                });
                break;
            }
        }
    }

    List<ControllerInfo> getConnectedControllers() {
        ArrayList<ControllerInfo> controllers = new ArrayList<>();
        synchronized (mLock) {
            for (int i = 0; i < mControllers.size(); i++) {
                controllers.add(mControllers.valueAt(i));
            }
        }
        return controllers;
    }

    void notifyCustomLayout(ControllerInfo controller, final List<CommandButton> layout) {
        notifyInternal(controller, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putParcelableArray(ARGUMENT_COMMAND_BUTTONS,
                        MediaUtils2.toCommandButtonParcelableArray(layout));
                controller.getControllerBinder().onEvent(SESSION_EVENT_SET_CUSTOM_LAYOUT, bundle);
            }
        });
    }

    void setAllowedCommands(ControllerInfo controller, final SessionCommandGroup2 commands) {
        synchronized (mLock) {
            mAllowedCommandGroupMap.put(controller, commands);
        }
        notifyInternal(controller, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_ALLOWED_COMMANDS, commands.toBundle());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_ALLOWED_COMMANDS_CHANGED, bundle);
            }
        });
    }

    public void sendCustomCommand(ControllerInfo controller, final SessionCommand2 command,
            final Bundle args, final ResultReceiver receiver) {
        if (receiver != null && controller == null) {
            throw new IllegalArgumentException("Controller shouldn't be null if result receiver is"
                    + " specified");
        }
        if (command == null) {
            throw new IllegalArgumentException("command shouldn't be null");
        }
        notifyInternal(controller, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                // TODO: Send this event through MediaSessionCompat.XXX()
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_CUSTOM_COMMAND, command.toBundle());
                bundle.putBundle(ARGUMENT_ARGUMENTS, args);
                bundle.putParcelable(ARGUMENT_RESULT_RECEIVER, receiver);
                controller.getControllerBinder().onEvent(SESSION_EVENT_SEND_CUSTOM_COMMAND, bundle);
            }
        });
    }

    public void sendCustomCommand(final SessionCommand2 command, final Bundle args) {
        if (command == null) {
            throw new IllegalArgumentException("command shouldn't be null");
        }
        final Bundle bundle = new Bundle();
        bundle.putBundle(ARGUMENT_CUSTOM_COMMAND, command.toBundle());
        bundle.putBundle(ARGUMENT_ARGUMENTS, args);
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                controller.getControllerBinder().onEvent(SESSION_EVENT_SEND_CUSTOM_COMMAND, bundle);
            }
        });
    }

    void notifyCurrentMediaItemChanged(final MediaItem2 item) {
        notifyAll(COMMAND_CODE_PLAYLIST_GET_CURRENT_MEDIA_ITEM, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_MEDIA_ITEM, item.toBundle());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_CURRENT_MEDIA_ITEM_CHANGED, bundle);
            }
        });
    }

    void notifyPlaybackInfoChanged(final PlaybackInfo info) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_PLAYBACK_INFO, info.toBundle());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_PLAYBACK_INFO_CHANGED, bundle);
            }
        });
    }

    void notifyPlayerStateChanged(final int state) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putInt(ARGUMENT_PLAYER_STATE, state);
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_PLAYER_STATE_CHANGED, bundle);
            }
        });
    }

    void notifyPlaybackSpeedChanged(final float speed) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putParcelable(
                        ARGUMENT_PLAYBACK_STATE_COMPAT, mSession.getPlaybackStateCompat());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_PLAYBACK_SPEED_CHANGED, bundle);
            }
        });
    }

    void notifyBufferingStateChanged(final MediaItem2 item, final int bufferingState) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_MEDIA_ITEM, item.toBundle());
                bundle.putInt(ARGUMENT_BUFFERING_STATE, bufferingState);
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_BUFFERING_STATE_CHAGNED, bundle);
            }
        });
    }

    void notifyError(final int errorCode, final Bundle extras) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putInt(ARGUMENT_ERROR_CODE, errorCode);
                bundle.putBundle(ARGUMENT_EXTRAS, extras);
                controller.getControllerBinder().onEvent(SESSION_EVENT_ON_ERROR, bundle);
            }
        });
    }

    void notifyRoutesInfoChanged(@NonNull final ControllerInfo controller,
            @Nullable final List<Bundle> routes) {
        notifyInternal(controller, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = null;
                if (routes != null) {
                    bundle = new Bundle();
                    bundle.putParcelableArray(ARGUMENT_ROUTE_BUNDLE, routes.toArray(new Bundle[0]));
                }
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_ROUTES_INFO_CHANGED, bundle);
            }
        });
    }

    void notifyPlaylistChanged(final List<MediaItem2> playlist,
            final MediaMetadata2 metadata) {
        notifyAll(COMMAND_CODE_PLAYLIST_GET_LIST, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putParcelableArray(ARGUMENT_PLAYLIST,
                        MediaUtils2.toMediaItem2ParcelableArray(playlist));
                bundle.putBundle(ARGUMENT_PLAYLIST_METADATA,
                        metadata == null ? null : metadata.toBundle());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_PLAYLIST_CHANGED, bundle);
            }
        });
    }

    void notifyPlaylistMetadataChanged(final MediaMetadata2 metadata) {
        notifyAll(SessionCommand2.COMMAND_CODE_PLAYLIST_GET_LIST_METADATA, new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putBundle(ARGUMENT_PLAYLIST_METADATA,
                        metadata == null ? null : metadata.toBundle());
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_PLAYLIST_METADATA_CHANGED, bundle);
            }
        });
    }

    void notifyRepeatModeChanged(final int repeatMode) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putInt(ARGUMENT_REPEAT_MODE, repeatMode);
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_REPEAT_MODE_CHANGED, bundle);
            }
        });
    }

    void notifyShuffleModeChanged(final int shuffleMode) {
        notifyAll(new Session2Runnable() {
            @Override
            public void run(ControllerInfo controller) throws RemoteException {
                Bundle bundle = new Bundle();
                bundle.putInt(ARGUMENT_SHUFFLE_MODE, shuffleMode);
                controller.getControllerBinder().onEvent(
                        SESSION_EVENT_ON_SHUFFLE_MODE_CHANGED, bundle);
            }
        });
    }

    private List<ControllerInfo> getControllers() {
        ArrayList<ControllerInfo> controllers = new ArrayList<>();
        synchronized (mLock) {
            for (int i = 0; i < mControllers.size(); i++) {
                controllers.add(mControllers.valueAt(i));
            }
        }
        return controllers;
    }

    private void notifyAll(@NonNull Session2Runnable runnable) {
        List<ControllerInfo> controllers = getControllers();
        for (int i = 0; i < controllers.size(); i++) {
            notifyInternal(controllers.get(i), runnable);
        }
    }

    private void notifyAll(int commandCode, @NonNull Session2Runnable runnable) {
        List<ControllerInfo> controllers = getControllers();
        for (int i = 0; i < controllers.size(); i++) {
            ControllerInfo controller = controllers.get(i);
            if (isAllowedCommand(controller, commandCode)) {
                notifyInternal(controller, runnable);
            }
        }
    }

    // TODO: Add a way to check permission from here.
    private void notifyInternal(@NonNull ControllerInfo controller,
            @NonNull Session2Runnable runnable) {
        if (controller == null || controller.getControllerBinder() == null) {
            return;
        }
        try {
            runnable.run(controller);
        } catch (DeadObjectException e) {
            if (DEBUG) {
                Log.d(TAG, controller.toString() + " is gone", e);
            }
            onControllerClosed(controller.getControllerBinder());
        } catch (RemoteException e) {
            // Currently it's TransactionTooLargeException or DeadSystemException.
            // We'd better to leave log for those cases because
            //   - TransactionTooLargeException means that we may need to fix our code.
            //     (e.g. add pagination or special way to deliver Bitmap)
            //   - DeadSystemException means that errors around it can be ignored.
            Log.w(TAG, "Exception in " + controller.toString(), e);
        }
    }

    private boolean isAllowedCommand(ControllerInfo controller, SessionCommand2 command) {
        SessionCommandGroup2 allowedCommands;
        synchronized (mLock) {
            allowedCommands = mAllowedCommandGroupMap.get(controller);
        }
        return allowedCommands != null && allowedCommands.hasCommand(command);
    }

    private boolean isAllowedCommand(ControllerInfo controller, int commandCode) {
        SessionCommandGroup2 allowedCommands;
        synchronized (mLock) {
            allowedCommands = mAllowedCommandGroupMap.get(controller);
        }
        return allowedCommands != null && allowedCommands.hasCommand(commandCode);
    }

    private void onCommand2(@NonNull IBinder caller, final int commandCode,
            @NonNull final Session2Runnable runnable) {
        // TODO: Prevent instantiation of SessionCommand2
        onCommand2(caller, new SessionCommand2(commandCode), runnable);
    }

    private void onCommand2(@NonNull IBinder caller, @NonNull final SessionCommand2 sessionCommand,
            @NonNull final Session2Runnable runnable) {
        final ControllerInfo controller;
        synchronized (mLock) {
            controller = mControllers.get(caller);
        }
        if (mSession == null || controller == null) {
            return;
        }
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (!isAllowedCommand(controller, sessionCommand)) {
                    return;
                }
                int commandCode = sessionCommand.getCommandCode();
                SessionCommand2 command = sCommandsForOnCommandRequest.get(commandCode);
                if (command != null) {
                    boolean accepted = mSession.getCallback().onCommandRequest(
                            mSession.getInstance(), controller, command);
                    if (!accepted) {
                        // Don't run rejected command.
                        if (DEBUG) {
                            Log.d(TAG, "Command (code=" + commandCode + ") from "
                                    + controller + " was rejected by " + mSession);
                        }
                        return;
                    }
                }
                try {
                    runnable.run(controller);
                } catch (RemoteException e) {
                    // Currently it's TransactionTooLargeException or DeadSystemException.
                    // We'd better to leave log for those cases because
                    //   - TransactionTooLargeException means that we may need to fix our code.
                    //     (e.g. add pagination or special way to deliver Bitmap)
                    //   - DeadSystemException means that errors around it can be ignored.
                    Log.w(TAG, "Exception in " + controller.toString(), e);
                }
            }
        });
    }

    private void onControllerClosed(IMediaControllerCallback iController) {
        ControllerInfo controller;
        synchronized (mLock) {
            controller = mControllers.remove(iController.asBinder());
            if (DEBUG) {
                Log.d(TAG, "releasing " + controller);
            }
        }
        if (controller == null) {
            return;
        }
        final ControllerInfo removedController = controller;
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                mSession.getCallback().onDisconnected(mSession.getInstance(), removedController);
            }
        });
    }

    private ControllerInfo createControllerInfo(Bundle extras) {
        IMediaControllerCallback callback = IMediaControllerCallback.Stub.asInterface(
                extras.getBinder(ARGUMENT_ICONTROLLER_CALLBACK));
        String packageName = extras.getString(ARGUMENT_PACKAGE_NAME);
        int uid = extras.getInt(ARGUMENT_UID);
        int pid = extras.getInt(ARGUMENT_PID);
        // TODO: sanity check for packageName, uid, and pid.

        return new ControllerInfo(mContext, uid, pid, packageName, callback);
    }

    private void connect(Bundle extras, final ResultReceiver cb) {
        final ControllerInfo controllerInfo = createControllerInfo(extras);
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                synchronized (mLock) {
                    // Keep connecting controllers.
                    // This helps sessions to call APIs in the onConnect()
                    // (e.g. setCustomLayout()) instead of pending them.
                    mConnectingControllers.add(controllerInfo.getId());
                }
                SessionCommandGroup2 allowedCommands = mSession.getCallback().onConnect(
                        mSession.getInstance(), controllerInfo);
                // Don't reject connection for the request from trusted app.
                // Otherwise server will fail to retrieve session's information to dispatch
                // media keys to.
                boolean accept = allowedCommands != null || controllerInfo.isTrusted();
                if (accept) {
                    if (DEBUG) {
                        Log.d(TAG, "Accepting connection, controllerInfo=" + controllerInfo
                                + " allowedCommands=" + allowedCommands);
                    }
                    if (allowedCommands == null) {
                        // For trusted apps, send non-null allowed commands to keep
                        // connection.
                        allowedCommands = new SessionCommandGroup2();
                    }
                    synchronized (mLock) {
                        mConnectingControllers.remove(controllerInfo.getId());
                        mControllers.put(controllerInfo.getId(), controllerInfo);
                        mAllowedCommandGroupMap.put(controllerInfo, allowedCommands);
                    }
                    // If connection is accepted, notify the current state to the
                    // controller. It's needed because we cannot call synchronous calls
                    // between session/controller.
                    // Note: We're doing this after the onConnectionChanged(), but there's
                    //       no guarantee that events here are notified after the
                    //       onConnected() because IMediaController2 is oneway (i.e. async
                    //       call) and Stub will use thread poll for incoming calls.
                    final Bundle resultData = new Bundle();
                    resultData.putBundle(ARGUMENT_ALLOWED_COMMANDS,
                            allowedCommands.toBundle());
                    resultData.putInt(ARGUMENT_PLAYER_STATE, mSession.getPlayerState());
                    resultData.putInt(ARGUMENT_BUFFERING_STATE, mSession.getBufferingState());
                    resultData.putParcelable(ARGUMENT_PLAYBACK_STATE_COMPAT,
                            mSession.getPlaybackStateCompat());
                    resultData.putInt(ARGUMENT_REPEAT_MODE, mSession.getRepeatMode());
                    resultData.putInt(ARGUMENT_SHUFFLE_MODE, mSession.getShuffleMode());
                    final List<MediaItem2> playlist = allowedCommands.hasCommand(
                            COMMAND_CODE_PLAYLIST_GET_LIST) ? mSession.getPlaylist() : null;
                    if (playlist != null) {
                        resultData.putParcelableArray(ARGUMENT_PLAYLIST,
                                MediaUtils2.toMediaItem2ParcelableArray(playlist));
                    }
                    final MediaItem2 currentMediaItem =
                            allowedCommands.hasCommand(COMMAND_CODE_PLAYLIST_GET_CURRENT_MEDIA_ITEM)
                                    ? mSession.getCurrentMediaItem() : null;
                    if (currentMediaItem != null) {
                        resultData.putBundle(ARGUMENT_MEDIA_ITEM, currentMediaItem.toBundle());
                    }
                    resultData.putBundle(ARGUMENT_PLAYBACK_INFO,
                            mSession.getPlaybackInfo().toBundle());
                    final MediaMetadata2 playlistMetadata = mSession.getPlaylistMetadata();
                    if (playlistMetadata != null) {
                        resultData.putBundle(ARGUMENT_PLAYLIST_METADATA,
                                playlistMetadata.toBundle());
                    }
                    // Double check if session is still there, because close() can be
                    // called in another thread.
                    if (mSession.isClosed()) {
                        return;
                    }
                    cb.send(CONNECT_RESULT_CONNECTED, resultData);
                } else {
                    synchronized (mLock) {
                        mConnectingControllers.remove(controllerInfo.getId());
                    }
                    if (DEBUG) {
                        Log.d(TAG, "Rejecting connection, controllerInfo=" + controllerInfo);
                    }
                    cb.send(CONNECT_RESULT_DISCONNECTED, null);
                }
            }
        });
    }

    private void disconnect(Bundle extras) {
        final ControllerInfo controllerInfo = createControllerInfo(extras);
        mSession.getCallbackExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (mSession.isClosed()) {
                    return;
                }
                mSession.getCallback().onDisconnected(mSession.getInstance(), controllerInfo);
            }
        });
    }

    @FunctionalInterface
    private interface Session2Runnable {
        void run(ControllerInfo controller) throws RemoteException;
    }
}