package androidx.media3.session;

import android.content.Context;
import android.os.Bundle;
import android.os.Looper;
import android.text.TextUtils;
import androidx.annotation.Nullable;
import androidx.media3.common.MediaItem;
import androidx.media3.common.MediaMetadata;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Consumer;
import androidx.media3.common.util.Log;
import androidx.media3.session.MediaBrowser;
import androidx.media3.session.MediaLibraryService;
import androidx.media3.session.legacy.MediaBrowserCompat;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
class MediaBrowserImplLegacy extends MediaControllerImplLegacy implements MediaBrowser.MediaBrowserImpl {
    private static final String TAG = "MB2ImplLegacy";
    private final HashMap<MediaLibraryService.LibraryParams, MediaBrowserCompat> browserCompats;
    private ImmutableMap<String, CommandButton> commandButtonsForMediaItems;
    private final MediaBrowser instance;
    private final HashMap<String, List<SubscribeCallback>> subscribeCallbacks;

    private class GetChildrenCallback extends MediaBrowserCompat.SubscriptionCallback {
        private final SettableFuture<LibraryResult<ImmutableList<MediaItem>>> future;
        private final String parentId;

        public GetChildrenCallback(SettableFuture<LibraryResult<ImmutableList<MediaItem>>> settableFuture, String str) {
            this.future = settableFuture;
            this.parentId = str;
        }

        private void onChildrenLoadedInternal(@Nullable String str, @Nullable List<MediaBrowserCompat.MediaItem> list) {
            if (TextUtils.isEmpty(str)) {
                Log.w(MediaBrowserImplLegacy.TAG, "GetChildrenCallback.onChildrenLoaded(): Ignoring empty parentId");
                return;
            }
            MediaBrowserCompat browserCompat = MediaBrowserImplLegacy.this.getBrowserCompat();
            if (browserCompat == null) {
                this.future.set(LibraryResult.ofError(-100));
                return;
            }
            browserCompat.unsubscribe(this.parentId, this);
            if (list == null) {
                this.future.set(LibraryResult.ofError(-1));
            } else {
                this.future.set(LibraryResult.ofItemList(LegacyConversions.convertBrowserItemListToMediaItemList(list), null));
            }
        }

        private void onErrorInternal() {
            this.future.set(LibraryResult.ofError(-1));
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onChildrenLoaded(@Nullable String str, @Nullable List<MediaBrowserCompat.MediaItem> list) {
            onChildrenLoadedInternal(str, list);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onError(@Nullable String str) {
            onErrorInternal();
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onChildrenLoaded(@Nullable String str, @Nullable List<MediaBrowserCompat.MediaItem> list, Bundle bundle) {
            onChildrenLoadedInternal(str, list);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onError(@Nullable String str, @Nullable Bundle bundle) {
            onErrorInternal();
        }
    }

    private class GetLibraryRootCallback extends MediaBrowserCompat.ConnectionCallback {
        private final MediaLibraryService.LibraryParams params;
        private final SettableFuture<LibraryResult<MediaItem>> result;

        public GetLibraryRootCallback(SettableFuture<LibraryResult<MediaItem>> settableFuture, MediaLibraryService.LibraryParams libraryParams) {
            this.result = settableFuture;
            this.params = libraryParams;
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.ConnectionCallback
        public void onConnected() {
            ArrayList parcelableArrayList;
            MediaBrowserCompat mediaBrowserCompat = (MediaBrowserCompat) MediaBrowserImplLegacy.this.browserCompats.get(this.params);
            if (mediaBrowserCompat == null) {
                this.result.set(LibraryResult.ofError(-1));
                return;
            }
            Bundle extras = mediaBrowserCompat.getExtras();
            if (extras != null && (parcelableArrayList = extras.getParcelableArrayList("androidx.media.utils.extras.CUSTOM_BROWSER_ACTION_ROOT_LIST")) != null) {
                ImmutableMap.Builder builderPutAll = null;
                for (int i2 = 0; i2 < parcelableArrayList.size(); i2++) {
                    CommandButton commandButtonConvertCustomBrowseActionToCommandButton = LegacyConversions.convertCustomBrowseActionToCommandButton((Bundle) parcelableArrayList.get(i2));
                    if (commandButtonConvertCustomBrowseActionToCommandButton != null) {
                        if (builderPutAll == null) {
                            builderPutAll = new ImmutableMap.Builder().putAll(MediaBrowserImplLegacy.this.commandButtonsForMediaItems);
                        }
                        builderPutAll.put(((SessionCommand) Assertions.checkNotNull(commandButtonConvertCustomBrowseActionToCommandButton.sessionCommand)).customAction, commandButtonConvertCustomBrowseActionToCommandButton);
                    }
                }
                if (builderPutAll != null) {
                    MediaBrowserImplLegacy.this.commandButtonsForMediaItems = builderPutAll.buildKeepingLast();
                }
            }
            this.result.set(LibraryResult.ofItem(MediaBrowserImplLegacy.this.createRootMediaItem(mediaBrowserCompat), LegacyConversions.convertToLibraryParams(MediaBrowserImplLegacy.this.context, extras)));
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.ConnectionCallback
        public void onConnectionFailed() {
            this.result.set(LibraryResult.ofError(-3));
            MediaBrowserImplLegacy.this.release();
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.ConnectionCallback
        public void onConnectionSuspended() {
            onConnectionFailed();
        }
    }

    private class SubscribeCallback extends MediaBrowserCompat.SubscriptionCallback {
        private final SettableFuture<LibraryResult<Void>> future;

        @Nullable
        private List<MediaBrowserCompat.MediaItem> receivedChildren;
        private final Bundle subscriptionOptions;
        private final String subscriptionParentId;

        public SubscribeCallback(String str, Bundle bundle, SettableFuture<LibraryResult<Void>> settableFuture) {
            this.subscriptionParentId = str;
            this.subscriptionOptions = bundle;
            this.future = settableFuture;
        }

        private /* synthetic */ void lambda$onChildrenLoadedInternal$1(String str, List list, MediaLibraryService.LibraryParams libraryParams, MediaBrowser.Listener listener) {
            listener.onChildrenChanged(MediaBrowserImplLegacy.this.getInstance(), str, list.size(), libraryParams);
        }

        private /* synthetic */ void lambda$onErrorInternal$0(String str, Bundle bundle, MediaBrowser.Listener listener) {
            listener.onChildrenChanged(MediaBrowserImplLegacy.this.getInstance(), str, Integer.MAX_VALUE, new MediaLibraryService.LibraryParams.Builder().setExtras(bundle).build());
        }

        private void onChildrenLoadedInternal(final String str, @Nullable final List<MediaBrowserCompat.MediaItem> list) {
            if (TextUtils.isEmpty(str)) {
                Log.w(MediaBrowserImplLegacy.TAG, "SubscribeCallback.onChildrenLoaded(): Ignoring empty parentId");
                return;
            }
            MediaBrowserCompat browserCompat = MediaBrowserImplLegacy.this.getBrowserCompat();
            if (browserCompat == null) {
                return;
            }
            if (list == null) {
                onError(this.subscriptionParentId, this.subscriptionOptions);
                return;
            }
            final MediaLibraryService.LibraryParams libraryParamsConvertToLibraryParams = LegacyConversions.convertToLibraryParams(MediaBrowserImplLegacy.this.context, browserCompat.getNotifyChildrenChangedOptions());
            this.receivedChildren = list;
            MediaBrowserImplLegacy.this.getInstance().notifyBrowserListener(new Consumer() { // from class: androidx.media3.session.p
            });
            this.future.set(LibraryResult.ofVoid());
        }

        private void onErrorInternal(final String str, final Bundle bundle) {
            if (this.future.isDone()) {
                MediaBrowserImplLegacy.this.getInstance().notifyBrowserListener(new Consumer() { // from class: androidx.media3.session.q
                });
            }
            this.future.set(LibraryResult.ofError(-1));
        }

        public boolean canServeGetChildrenRequest(String str, int i2) {
            return this.subscriptionParentId.equals(str) && this.receivedChildren != null && i2 == this.subscriptionOptions.getInt(MediaBrowserCompat.EXTRA_PAGE, 0);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onChildrenLoaded(@Nullable String str, @Nullable List<MediaBrowserCompat.MediaItem> list) {
            onChildrenLoadedInternal(this.subscriptionParentId, list);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onError(@Nullable String str) {
            onError(this.subscriptionParentId, this.subscriptionOptions);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onChildrenLoaded(@Nullable String str, @Nullable List<MediaBrowserCompat.MediaItem> list, @Nullable Bundle bundle) {
            onChildrenLoadedInternal(this.subscriptionParentId, list);
        }

        @Override // androidx.media3.session.legacy.MediaBrowserCompat.SubscriptionCallback
        public void onError(@Nullable String str, @Nullable Bundle bundle) {
            onErrorInternal(this.subscriptionParentId, this.subscriptionOptions);
        }
    }

    MediaBrowserImplLegacy(Context context, MediaBrowser mediaBrowser, SessionToken sessionToken, Bundle bundle, Looper looper, androidx.media3.common.util.BitmapLoader bitmapLoader, long j2) {
        super(context, mediaBrowser, sessionToken, bundle, looper, bitmapLoader, j2);
        this.browserCompats = new HashMap<>();
        this.subscribeCallbacks = new HashMap<>();
        this.instance = mediaBrowser;
        this.commandButtonsForMediaItems = ImmutableMap.of();
    }

    private static Bundle createOptionsForSubscription(@Nullable MediaLibraryService.LibraryParams libraryParams) {
        return libraryParams == null ? new Bundle() : new Bundle(libraryParams.extras);
    }

    private static Bundle createOptionsWithPagingInfo(@Nullable MediaLibraryService.LibraryParams libraryParams, int i2, int i3) {
        Bundle bundleCreateOptionsForSubscription = createOptionsForSubscription(libraryParams);
        bundleCreateOptionsForSubscription.putInt(MediaBrowserCompat.EXTRA_PAGE, i2);
        bundleCreateOptionsForSubscription.putInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, i3);
        return bundleCreateOptionsForSubscription;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public MediaItem createRootMediaItem(MediaBrowserCompat mediaBrowserCompat) {
        String root = mediaBrowserCompat.getRoot();
        return new MediaItem.Builder().setMediaId(root).setMediaMetadata(new MediaMetadata.Builder().setIsBrowsable(Boolean.TRUE).setMediaType(20).setIsPlayable(Boolean.FALSE).setExtras(mediaBrowserCompat.getExtras()).build()).build();
    }

    private void evictChildrenFromSubscription(String str) {
        List<SubscribeCallback> list = this.subscribeCallbacks.get(str);
        if (list == null) {
            return;
        }
        for (int i2 = 0; i2 < list.size(); i2++) {
            if (list.get(i2).receivedChildren != null) {
                list.get(i2).receivedChildren = null;
                return;
            }
        }
    }

    private MediaBrowserCompat getBrowserCompat(MediaLibraryService.LibraryParams libraryParams) {
        return this.browserCompats.get(libraryParams);
    }

    @Nullable
    private List<MediaBrowserCompat.MediaItem> getChildrenFromSubscription(String str, int i2) {
        List<SubscribeCallback> list = this.subscribeCallbacks.get(str);
        if (list == null) {
            return null;
        }
        for (int i3 = 0; i3 < list.size(); i3++) {
            if (list.get(i3).canServeGetChildrenRequest(str, i2)) {
                return list.get(i3).receivedChildren;
            }
        }
        return null;
    }

    @Nullable
    private static Bundle getExtras(@Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (libraryParams != null) {
            return libraryParams.extras;
        }
        return null;
    }

    @Override // androidx.media3.session.MediaControllerImplLegacy, androidx.media3.session.MediaController.MediaControllerImpl
    public SessionCommands getAvailableSessionCommands() {
        return getBrowserCompat() != null ? super.getAvailableSessionCommands().buildUpon().addAllLibraryCommands().build() : super.getAvailableSessionCommands();
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture getChildren(String str, int i2, int i3, @Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_GET_CHILDREN)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        Bundle bundleCreateOptionsWithPagingInfo = createOptionsWithPagingInfo(libraryParams, i2, i3);
        SettableFuture settableFutureCreate = SettableFuture.create();
        List<MediaBrowserCompat.MediaItem> childrenFromSubscription = getChildrenFromSubscription(str, i2);
        evictChildrenFromSubscription(str);
        if (childrenFromSubscription != null) {
            settableFutureCreate.set(LibraryResult.ofItemList(LegacyConversions.convertBrowserItemListToMediaItemList(childrenFromSubscription), new MediaLibraryService.LibraryParams.Builder().setExtras(bundleCreateOptionsWithPagingInfo).build()));
        } else {
            browserCompat.subscribe(str, bundleCreateOptionsWithPagingInfo, new GetChildrenCallback(settableFutureCreate, str));
        }
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaControllerImplLegacy, androidx.media3.session.MediaController.MediaControllerImpl
    public ImmutableList<CommandButton> getCommandButtonsForMediaItem(MediaItem mediaItem) {
        ImmutableList immutableList = mediaItem.mediaMetadata.supportedCommands;
        ImmutableList.Builder builder = new ImmutableList.Builder();
        for (int i2 = 0; i2 < immutableList.size(); i2++) {
            CommandButton commandButton = (CommandButton) this.commandButtonsForMediaItems.get(immutableList.get(i2));
            if (commandButton != null && commandButton.sessionCommand != null) {
                builder.add(commandButton);
            }
        }
        return builder.build();
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture getItem(String str) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_GET_ITEM)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        final SettableFuture settableFutureCreate = SettableFuture.create();
        browserCompat.getItem(str, new MediaBrowserCompat.ItemCallback() { // from class: androidx.media3.session.MediaBrowserImplLegacy.1
            @Override // androidx.media3.session.legacy.MediaBrowserCompat.ItemCallback
            public void onError(String str2) {
                settableFutureCreate.set(LibraryResult.ofError(-1));
            }

            @Override // androidx.media3.session.legacy.MediaBrowserCompat.ItemCallback
            public void onItemLoaded(MediaBrowserCompat.MediaItem mediaItem) {
                if (mediaItem != null) {
                    settableFutureCreate.set(LibraryResult.ofItem(LegacyConversions.convertToMediaItem(mediaItem), null));
                } else {
                    settableFutureCreate.set(LibraryResult.ofError(-3));
                }
            }
        });
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture getLibraryRoot(@Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_GET_LIBRARY_ROOT)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        SettableFuture settableFutureCreate = SettableFuture.create();
        MediaBrowserCompat browserCompat = getBrowserCompat(libraryParams);
        if (browserCompat != null) {
            settableFutureCreate.set(LibraryResult.ofItem(createRootMediaItem(browserCompat), null));
        } else {
            Bundle bundle = libraryParams == null ? new Bundle() : LegacyConversions.convertToRootHints(libraryParams);
            bundle.putInt("androidx.media.utils.MediaBrowserCompat.extras.CUSTOM_BROWSER_ACTION_LIMIT", getInstance().getMaxCommandsForMediaItems());
            MediaBrowserCompat mediaBrowserCompat = new MediaBrowserCompat(getContext(), getConnectedToken().getComponentName(), new GetLibraryRootCallback(settableFutureCreate, libraryParams), bundle);
            this.browserCompats.put(libraryParams, mediaBrowserCompat);
            mediaBrowserCompat.connect();
        }
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture getSearchResult(String str, int i2, int i3, @Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_GET_SEARCH_RESULT)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        final SettableFuture settableFutureCreate = SettableFuture.create();
        Bundle bundleCreateOptionsWithPagingInfo = createOptionsWithPagingInfo(libraryParams, i2, i3);
        bundleCreateOptionsWithPagingInfo.putInt(MediaBrowserCompat.EXTRA_PAGE, i2);
        bundleCreateOptionsWithPagingInfo.putInt(MediaBrowserCompat.EXTRA_PAGE_SIZE, i3);
        browserCompat.search(str, bundleCreateOptionsWithPagingInfo, new MediaBrowserCompat.SearchCallback() { // from class: androidx.media3.session.MediaBrowserImplLegacy.3
            @Override // androidx.media3.session.legacy.MediaBrowserCompat.SearchCallback
            public void onError(String str2, @Nullable Bundle bundle) {
                settableFutureCreate.set(LibraryResult.ofError(-1));
            }

            @Override // androidx.media3.session.legacy.MediaBrowserCompat.SearchCallback
            public void onSearchResult(String str2, @Nullable Bundle bundle, List<MediaBrowserCompat.MediaItem> list) {
                settableFutureCreate.set(LibraryResult.ofItemList(LegacyConversions.convertBrowserItemListToMediaItemList(list), null));
            }
        });
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaControllerImplLegacy, androidx.media3.session.MediaController.MediaControllerImpl
    public void release() {
        Iterator<MediaBrowserCompat> it = this.browserCompats.values().iterator();
        while (it.hasNext()) {
            it.next().disconnect();
        }
        this.browserCompats.clear();
        super.release();
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture search(String str, @Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_SEARCH)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        browserCompat.search(str, getExtras(libraryParams), new MediaBrowserCompat.SearchCallback() { // from class: androidx.media3.session.MediaBrowserImplLegacy.2
            private /* synthetic */ void lambda$onError$1(String str2, MediaBrowser.Listener listener) {
                listener.onSearchResultChanged(MediaBrowserImplLegacy.this.getInstance(), str2, 0, null);
            }

            private /* synthetic */ void lambda$onSearchResult$0(String str2, List list, MediaBrowser.Listener listener) {
                listener.onSearchResultChanged(MediaBrowserImplLegacy.this.getInstance(), str2, list.size(), null);
            }

            @Override // androidx.media3.session.legacy.MediaBrowserCompat.SearchCallback
            public void onError(final String str2, @Nullable Bundle bundle) {
                MediaBrowserImplLegacy.this.getInstance().notifyBrowserListener(new Consumer() { // from class: androidx.media3.session.o
                });
            }

            @Override // androidx.media3.session.legacy.MediaBrowserCompat.SearchCallback
            public void onSearchResult(final String str2, @Nullable Bundle bundle, final List<MediaBrowserCompat.MediaItem> list) {
                MediaBrowserImplLegacy.this.getInstance().notifyBrowserListener(new Consumer() { // from class: androidx.media3.session.n
                });
            }
        });
        return Futures.immediateFuture(LibraryResult.ofVoid());
    }

    @Override // androidx.media3.session.MediaControllerImplLegacy, androidx.media3.session.MediaController.MediaControllerImpl
    public ListenableFuture sendCustomCommand(SessionCommand sessionCommand, Bundle bundle) {
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(new SessionResult(-4));
        }
        final SettableFuture settableFutureCreate = SettableFuture.create();
        browserCompat.sendCustomAction(sessionCommand.customAction, bundle, new MediaBrowserCompat.CustomActionCallback() { // from class: androidx.media3.session.MediaBrowserImplLegacy.4
            @Override // androidx.media3.session.legacy.MediaBrowserCompat.CustomActionCallback
            public void onError(String str, @Nullable Bundle bundle2, @Nullable Bundle bundle3) {
                Bundle bundle4 = new Bundle(bundle2);
                bundle4.putAll(bundle3);
                settableFutureCreate.set(new SessionResult(-1, bundle4));
            }

            @Override // androidx.media3.session.legacy.MediaBrowserCompat.CustomActionCallback
            public void onResult(String str, @Nullable Bundle bundle2, @Nullable Bundle bundle3) {
                Bundle bundle4 = new Bundle(bundle2);
                bundle4.putAll(bundle3);
                settableFutureCreate.set(new SessionResult(0, bundle4));
            }
        });
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture subscribe(String str, @Nullable MediaLibraryService.LibraryParams libraryParams) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_SUBSCRIBE)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        Bundle bundleCreateOptionsForSubscription = createOptionsForSubscription(libraryParams);
        SettableFuture settableFutureCreate = SettableFuture.create();
        SubscribeCallback subscribeCallback = new SubscribeCallback(str, bundleCreateOptionsForSubscription, settableFutureCreate);
        List<SubscribeCallback> arrayList = this.subscribeCallbacks.get(str);
        if (arrayList == null) {
            arrayList = new ArrayList<>();
            this.subscribeCallbacks.put(str, arrayList);
        }
        arrayList.add(subscribeCallback);
        browserCompat.subscribe(str, bundleCreateOptionsForSubscription, subscribeCallback);
        return settableFutureCreate;
    }

    @Override // androidx.media3.session.MediaBrowser.MediaBrowserImpl
    public ListenableFuture unsubscribe(String str) {
        if (!getInstance().isSessionCommandAvailable(SessionCommand.COMMAND_CODE_LIBRARY_UNSUBSCRIBE)) {
            return Futures.immediateFuture(LibraryResult.ofError(-4));
        }
        MediaBrowserCompat browserCompat = getBrowserCompat();
        if (browserCompat == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-100));
        }
        List<SubscribeCallback> list = this.subscribeCallbacks.get(str);
        if (list == null) {
            return Futures.immediateFuture(LibraryResult.ofError(-3));
        }
        for (int i2 = 0; i2 < list.size(); i2++) {
            browserCompat.unsubscribe(str, list.get(i2));
        }
        return Futures.immediateFuture(LibraryResult.ofVoid());
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // androidx.media3.session.MediaControllerImplLegacy
    public MediaBrowser getInstance() {
        return this.instance;
    }
}