package androidx.media3.session;

import android.app.PendingIntent;
import android.media.session.MediaSession;
import android.os.Binder;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.text.TextUtils;
import android.view.Surface;
import androidx.annotation.Nullable;
import androidx.core.util.ObjectsCompat;
import androidx.media3.common.AudioAttributes;
import androidx.media3.common.BundleListRetriever;
import androidx.media3.common.MediaItem;
import androidx.media3.common.MediaMetadata;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.PlaybackParameters;
import androidx.media3.common.Player;
import androidx.media3.common.Rating;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.TrackSelectionOverride;
import androidx.media3.common.TrackSelectionParameters;
import androidx.media3.common.Tracks;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.BundleCollectionUtil;
import androidx.media3.common.util.Consumer;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.Util;
import androidx.media3.session.ConnectedControllersManager;
import androidx.media3.session.IMediaSession;
import androidx.media3.session.MediaLibraryService;
import androidx.media3.session.MediaSession;
import androidx.media3.session.PlayerInfo;
import androidx.media3.session.legacy.MediaSessionManager;
import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.UnmodifiableIterator;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.SettableFuture;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;

/* JADX INFO: loaded from: classes.dex */
final class MediaSessionStub extends IMediaSession.Stub {
    private static final String TAG = "MediaSessionStub";
    public static final int UNKNOWN_SEQUENCE_NUMBER = Integer.MIN_VALUE;
    public static final int VERSION_INT = 5;
    private final ConnectedControllersManager<IBinder> connectedControllersManager;
    private int nextUniqueTrackGroupIdPrefix;
    private final WeakReference<MediaSessionImpl> sessionImpl;
    private final Set<MediaSession.ControllerInfo> pendingControllers = Collections.synchronizedSet(new HashSet());
    private ImmutableBiMap<TrackGroup, String> trackGroupIdMap = ImmutableBiMap.of();

    static final class Controller2Cb implements MediaSession.ControllerCb {
        private final int controllerInterfaceVersion;
        private final IMediaController iController;

        public Controller2Cb(IMediaController iMediaController, int i2) {
            this.iController = iMediaController;
            this.controllerInterfaceVersion = i2;
        }

        public boolean equals(@Nullable Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null || obj.getClass() != Controller2Cb.class) {
                return false;
            }
            return Objects.equals(getCallbackBinder(), ((Controller2Cb) obj).getCallbackBinder());
        }

        public IBinder getCallbackBinder() {
            return this.iController.asBinder();
        }

        public int hashCode() {
            return ObjectsCompat.hash(getCallbackBinder());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onAvailableCommandsChangedFromPlayer(int i2, Player.Commands commands) throws RemoteException {
            this.iController.onAvailableCommandsChangedFromPlayer(i2, commands.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onAvailableCommandsChangedFromSession(int i2, SessionCommands sessionCommands, Player.Commands commands) throws RemoteException {
            this.iController.onAvailableCommandsChangedFromSession(i2, sessionCommands.toBundle(), commands.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onChildrenChanged(int i2, String str, int i3, @Nullable MediaLibraryService.LibraryParams libraryParams) throws RemoteException {
            this.iController.onChildrenChanged(i2, str, i3, libraryParams == null ? null : libraryParams.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onDisconnected(int i2) {
            SessionUtil.disconnectIMediaController(this.iController);
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onError(int i2, SessionError sessionError) throws RemoteException {
            this.iController.onError(i2, sessionError.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onLibraryResult(int i2, LibraryResult<?> libraryResult) throws RemoteException {
            this.iController.onLibraryResult(i2, libraryResult.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onPeriodicSessionPositionInfoChanged(int i2, SessionPositionInfo sessionPositionInfo, boolean z2, boolean z3, int i3) throws RemoteException {
            this.iController.onPeriodicSessionPositionInfoChanged(i2, sessionPositionInfo.filterByAvailableCommands(z2, z3).toBundle(i3));
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onPlayerInfoChanged(int i2, PlayerInfo playerInfo, Player.Commands commands, boolean z2, boolean z3) throws RemoteException {
            Assertions.checkState(this.controllerInterfaceVersion != 0);
            boolean z4 = z2 || !commands.contains(17);
            boolean z5 = z3 || !commands.contains(30);
            if (this.controllerInterfaceVersion < 2) {
                this.iController.onPlayerInfoChanged(i2, playerInfo.filterByAvailableCommands(commands, z2, true).toBundleForRemoteProcess(this.controllerInterfaceVersion), z4);
            } else {
                PlayerInfo playerInfoFilterByAvailableCommands = playerInfo.filterByAvailableCommands(commands, z2, z3);
                this.iController.onPlayerInfoChangedWithExclusions(i2, this.iController instanceof MediaControllerStub ? playerInfoFilterByAvailableCommands.toBundleInProcess() : playerInfoFilterByAvailableCommands.toBundleForRemoteProcess(this.controllerInterfaceVersion), new PlayerInfo.BundlingExclusions(z4, z5).toBundle());
            }
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onRenderedFirstFrame(int i2) throws RemoteException {
            this.iController.onRenderedFirstFrame(i2);
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onSearchResultChanged(int i2, String str, int i3, @Nullable MediaLibraryService.LibraryParams libraryParams) throws RemoteException {
            this.iController.onSearchResultChanged(i2, str, i3, libraryParams == null ? null : libraryParams.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onSessionActivityChanged(int i2, @Nullable PendingIntent pendingIntent) throws RemoteException {
            this.iController.onSessionActivityChanged(i2, pendingIntent);
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onSessionExtrasChanged(int i2, Bundle bundle) throws RemoteException {
            this.iController.onExtrasChanged(i2, bundle);
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void onSessionResult(int i2, SessionResult sessionResult) throws RemoteException {
            this.iController.onSessionResult(i2, sessionResult.toBundle());
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void sendCustomCommand(int i2, SessionCommand sessionCommand, Bundle bundle) throws RemoteException {
            this.iController.onCustomCommand(i2, sessionCommand.toBundle(), bundle);
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void setCustomLayout(int i2, List<CommandButton> list) throws RemoteException {
            this.iController.onSetCustomLayout(i2, BundleCollectionUtil.toBundleList(list, new C0254f()));
        }

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void setMediaButtonPreferences(int i2, List<CommandButton> list) throws RemoteException {
            if (this.controllerInterfaceVersion >= 7) {
                this.iController.onSetMediaButtonPreferences(i2, BundleCollectionUtil.toBundleList(list, new C0254f()));
            } else {
                this.iController.onSetCustomLayout(i2, BundleCollectionUtil.toBundleList(CommandButton.getCustomLayoutFromMediaButtonPreferences(list, true, true), new C0254f()));
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    interface ControllerPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo);
    }

    /* JADX INFO: Access modifiers changed from: private */
    interface MediaItemPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List<MediaItem> list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    interface MediaItemsWithStartPositionPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.MediaItemsWithStartPosition mediaItemsWithStartPosition);
    }

    /* JADX INFO: Access modifiers changed from: private */
    interface SessionTask<T, K extends MediaSessionImpl> {
        T run(K k2, MediaSession.ControllerInfo controllerInfo, int i2);
    }

    public MediaSessionStub(MediaSessionImpl mediaSessionImpl) {
        this.sessionImpl = new WeakReference<>(mediaSessionImpl);
        this.connectedControllersManager = new ConnectedControllersManager<>(mediaSessionImpl);
    }

    private <K extends MediaSessionImpl> void dispatchSessionTaskWithSessionCommand(IMediaController iMediaController, int i2, int i3, SessionTask<ListenableFuture, K> sessionTask) {
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, null, i3, sessionTask);
    }

    private String generateUniqueTrackGroupId(TrackGroup trackGroup) {
        StringBuilder sb = new StringBuilder();
        int i2 = this.nextUniqueTrackGroupIdPrefix;
        this.nextUniqueTrackGroupIdPrefix = i2 + 1;
        sb.append(Util.intToStringMaxRadix(i2));
        sb.append("-");
        sb.append(trackGroup.id);
        return sb.toString();
    }

    private static <K extends MediaSessionImpl> SessionTask<ListenableFuture, K> handleMediaItemsWhenReady(final SessionTask<ListenableFuture, K> sessionTask, final MediaItemPlayerTask mediaItemPlayerTask) {
        return new SessionTask() { // from class: androidx.media3.session.H5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
                return MediaSessionStub.lambda$handleMediaItemsWhenReady$6(sessionTask, mediaItemPlayerTask, mediaSessionImpl, controllerInfo, i2);
            }
        };
    }

    private static <K extends MediaSessionImpl> SessionTask<ListenableFuture, K> handleMediaItemsWithStartPositionWhenReady(final SessionTask<ListenableFuture, K> sessionTask, final MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask) {
        return new SessionTask() { // from class: androidx.media3.session.u5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
                return MediaSessionStub.lambda$handleMediaItemsWithStartPositionWhenReady$9(sessionTask, mediaItemsWithStartPositionPlayerTask, mediaSessionImpl, controllerInfo, i2);
            }
        };
    }

    private static <T, K extends MediaSessionImpl> ListenableFuture handleSessionTaskWhenReady(final K k2, MediaSession.ControllerInfo controllerInfo, int i2, SessionTask<ListenableFuture, K> sessionTask, final Consumer<ListenableFuture> consumer) {
        if (k2.isReleased()) {
            return Futures.immediateVoidFuture();
        }
        final ListenableFuture listenableFutureRun = sessionTask.run(k2, controllerInfo, i2);
        final SettableFuture settableFutureCreate = SettableFuture.create();
        listenableFutureRun.addListener(new Runnable() { // from class: androidx.media3.session.N4
            @Override // java.lang.Runnable
            public final void run() {
                MediaSessionStub.lambda$handleSessionTaskWhenReady$16(k2, settableFutureCreate, consumer, listenableFutureRun);
            }
        }, MoreExecutors.directExecutor());
        return settableFutureCreate;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$addMediaItem$34(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, ImmutableList.of(mediaItem));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$addMediaItemWithIndex$36(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, ImmutableList.of(mediaItem));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItemWithIndex$37(int i2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
        playerWrapper.addMediaItems(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$addMediaItems$38(List list, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$addMediaItemsWithIndex$40(List list, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItemsWithIndex$41(int i2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
        playerWrapper.addMediaItems(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$connect$17(MediaSession.ControllerInfo controllerInfo, MediaSessionImpl mediaSessionImpl, IMediaController iMediaController) throws Throwable {
        Player.Commands commands;
        boolean z2 = false;
        try {
            this.pendingControllers.remove(controllerInfo);
        } catch (Throwable th) {
            th = th;
        }
        if (mediaSessionImpl.isReleased()) {
            SessionUtil.disconnectIMediaController(iMediaController);
            return;
        }
        IBinder callbackBinder = ((Controller2Cb) Assertions.checkStateNotNull((Controller2Cb) controllerInfo.getControllerCb())).getCallbackBinder();
        MediaSession.ConnectionResult connectionResultOnConnectOnHandler = mediaSessionImpl.onConnectOnHandler(controllerInfo);
        if (!connectionResultOnConnectOnHandler.isAccepted && !controllerInfo.isTrusted()) {
            SessionUtil.disconnectIMediaController(iMediaController);
            return;
        }
        if (!connectionResultOnConnectOnHandler.isAccepted) {
            connectionResultOnConnectOnHandler = MediaSession.ConnectionResult.accept(SessionCommands.EMPTY, Player.Commands.EMPTY);
        }
        if (this.connectedControllersManager.isConnected(controllerInfo)) {
            Log.w(TAG, "Controller " + controllerInfo + " has sent connection request multiple times");
        }
        this.connectedControllersManager.addController(callbackBinder, controllerInfo, connectionResultOnConnectOnHandler.availableSessionCommands, connectionResultOnConnectOnHandler.availablePlayerCommands);
        SequencedFutureManager sequencedFutureManager = this.connectedControllersManager.getSequencedFutureManager(controllerInfo);
        if (sequencedFutureManager == null) {
            Log.w(TAG, "Ignoring connection request from unknown controller info");
            SessionUtil.disconnectIMediaController(iMediaController);
            return;
        }
        PlayerWrapper playerWrapper = mediaSessionImpl.getPlayerWrapper();
        PlayerInfo playerInfo = mediaSessionImpl.getPlayerInfo();
        PlaybackException playbackException = mediaSessionImpl.getPlaybackException();
        if (playbackException == null) {
            commands = connectionResultOnConnectOnHandler.availablePlayerCommands;
        } else {
            this.connectedControllersManager.setPlaybackException(controllerInfo, playbackException, connectionResultOnConnectOnHandler.availablePlayerCommands);
            playerInfo = MediaSessionImpl.createPlayerInfoForCustomPlaybackException(playerInfo, playbackException);
            commands = (Player.Commands) Assertions.checkNotNull(MediaSessionImpl.createPlayerCommandsForCustomErrorState(connectionResultOnConnectOnHandler.availablePlayerCommands));
        }
        Player.Commands commands2 = commands;
        PlayerInfo playerInfoGenerateAndCacheUniqueTrackGroupIds = generateAndCacheUniqueTrackGroupIds(playerInfo);
        MediaSession.Token platformToken = mediaSessionImpl.getPlatformToken();
        PendingIntent sessionActivity = connectionResultOnConnectOnHandler.sessionActivity;
        if (sessionActivity == null) {
            sessionActivity = mediaSessionImpl.getSessionActivity();
        }
        PendingIntent pendingIntent = sessionActivity;
        ImmutableList<CommandButton> customLayout = connectionResultOnConnectOnHandler.customLayout;
        if (customLayout == null) {
            customLayout = mediaSessionImpl.getCustomLayout();
        }
        ImmutableList<CommandButton> immutableList = customLayout;
        ImmutableList<CommandButton> mediaButtonPreferences = connectionResultOnConnectOnHandler.mediaButtonPreferences;
        if (mediaButtonPreferences == null) {
            mediaButtonPreferences = mediaSessionImpl.getMediaButtonPreferences();
        }
        ImmutableList<CommandButton> immutableList2 = mediaButtonPreferences;
        ImmutableList<CommandButton> commandButtonsForMediaItems = mediaSessionImpl.getCommandButtonsForMediaItems();
        SessionCommands sessionCommands = connectionResultOnConnectOnHandler.availableSessionCommands;
        Player.Commands availableCommands = playerWrapper.getAvailableCommands();
        Bundle extras = mediaSessionImpl.getToken().getExtras();
        Bundle sessionExtras = connectionResultOnConnectOnHandler.sessionExtras;
        if (sessionExtras == null) {
            sessionExtras = mediaSessionImpl.getSessionExtras();
        }
        try {
            ConnectionState connectionState = new ConnectionState(1008000300, 5, this, pendingIntent, immutableList, immutableList2, commandButtonsForMediaItems, sessionCommands, commands2, availableCommands, extras, sessionExtras, playerInfoGenerateAndCacheUniqueTrackGroupIds, platformToken);
            if (mediaSessionImpl.isReleased()) {
                SessionUtil.disconnectIMediaController(iMediaController);
                return;
            }
            try {
                try {
                    iMediaController.onConnected(sequencedFutureManager.obtainNextSequenceNumber(), iMediaController instanceof MediaControllerStub ? connectionState.toBundleInProcess() : connectionState.toBundleForRemoteProcess(controllerInfo.getInterfaceVersion()));
                    z2 = true;
                } catch (RemoteException unused) {
                }
                if (z2) {
                    mediaSessionImpl.onPostConnectOnHandler(controllerInfo);
                }
                if (z2) {
                    return;
                }
                SessionUtil.disconnectIMediaController(iMediaController);
                return;
            } catch (Throwable th2) {
                th = th2;
            }
        } catch (Throwable th3) {
            th = th3;
        }
        if (!z2) {
            SessionUtil.disconnectIMediaController(iMediaController);
        }
        throw th;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$dispatchSessionTaskWithSessionCommand$15(MediaSession.ControllerInfo controllerInfo, SessionCommand sessionCommand, MediaSessionImpl mediaSessionImpl, int i2, int i3, SessionTask sessionTask) {
        if (this.connectedControllersManager.isConnected(controllerInfo)) {
            if (sessionCommand != null) {
                if (!this.connectedControllersManager.isSessionCommandAvailable(controllerInfo, sessionCommand)) {
                    sendSessionResult(mediaSessionImpl, controllerInfo, i2, new SessionResult(-4));
                    return;
                }
            } else if (!this.connectedControllersManager.isSessionCommandAvailable(controllerInfo, i3)) {
                sendSessionResult(mediaSessionImpl, controllerInfo, i2, new SessionResult(-4));
                return;
            }
            sessionTask.run(mediaSessionImpl, controllerInfo, i2);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$flushCommandQueue$64(MediaSession.ControllerInfo controllerInfo) {
        this.connectedControllersManager.flushCommandQueue(controllerInfo);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$getChildren$68(String str, int i2, int i3, MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
        return mediaLibrarySessionImpl.onGetChildrenOnHandler(controllerInfo, str, i2, i3, libraryParams);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$getItem$67(String str, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaLibrarySessionImpl.onGetItemOnHandler(controllerInfo, str);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$getLibraryRoot$66(MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaLibrarySessionImpl.onGetLibraryRootOnHandler(controllerInfo, libraryParams);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$getSearchResult$70(String str, int i2, int i3, MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
        return mediaLibrarySessionImpl.onGetSearchResultOnHandler(controllerInfo, str, i2, i3, libraryParams);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$handleMediaItemsWhenReady$4(MediaSessionImpl mediaSessionImpl, MediaItemPlayerTask mediaItemPlayerTask, MediaSession.ControllerInfo controllerInfo, List list) {
        if (mediaSessionImpl.isReleased()) {
            return;
        }
        mediaItemPlayerTask.run(mediaSessionImpl.getPlayerWrapper(), controllerInfo, list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$handleMediaItemsWhenReady$6(SessionTask sessionTask, final MediaItemPlayerTask mediaItemPlayerTask, final MediaSessionImpl mediaSessionImpl, final MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.isReleased() ? Futures.immediateFuture(new SessionResult(-100)) : Util.transformFutureAsync((ListenableFuture) sessionTask.run(mediaSessionImpl, controllerInfo, i2), new AsyncFunction() { // from class: androidx.media3.session.T4
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$handleMediaItemsWithStartPositionWhenReady$7(MediaSessionImpl mediaSessionImpl, MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask, MediaSession.MediaItemsWithStartPosition mediaItemsWithStartPosition) {
        if (mediaSessionImpl.isReleased()) {
            return;
        }
        mediaItemsWithStartPositionPlayerTask.run(mediaSessionImpl.getPlayerWrapper(), mediaItemsWithStartPosition);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$handleMediaItemsWithStartPositionWhenReady$9(SessionTask sessionTask, final MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask, final MediaSessionImpl mediaSessionImpl, final MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.isReleased() ? Futures.immediateFuture(new SessionResult(-100)) : Util.transformFutureAsync((ListenableFuture) sessionTask.run(mediaSessionImpl, controllerInfo, i2), new AsyncFunction() { // from class: androidx.media3.session.J4
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$handleSessionTaskWhenReady$16(MediaSessionImpl mediaSessionImpl, SettableFuture settableFuture, Consumer consumer, ListenableFuture listenableFuture) {
        if (mediaSessionImpl.isReleased()) {
            settableFuture.set((Object) null);
            return;
        }
        try {
            consumer.accept(listenableFuture);
            settableFuture.set((Object) null);
        } catch (Throwable th) {
            settableFuture.setException(th);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$onCustomCommand$24(SessionCommand sessionCommand, Bundle bundle, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onCustomCommandOnHandler(controllerInfo, sessionCommand, bundle);
    }

    private /* synthetic */ void lambda$playForControllerInfo$19(MediaSession.ControllerInfo controllerInfo, PlayerWrapper playerWrapper) {
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        if (mediaSessionImpl == null || mediaSessionImpl.isReleased()) {
            return;
        }
        mediaSessionImpl.handleMediaControllerPlayRequest(controllerInfo, false);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$queueSessionTaskWithPlayerCommandForControllerInfo$13(SessionTask sessionTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return (ListenableFuture) sessionTask.run(mediaSessionImpl, controllerInfo, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$queueSessionTaskWithPlayerCommandForControllerInfo$14(final MediaSession.ControllerInfo controllerInfo, int i2, final MediaSessionImpl mediaSessionImpl, final int i3, final SessionTask sessionTask) {
        if (!this.connectedControllersManager.isPlayerCommandAvailable(controllerInfo, i2)) {
            sendSessionResult(mediaSessionImpl, controllerInfo, i3, new SessionResult(-4));
            return;
        }
        int iOnPlayerCommandRequestOnHandler = mediaSessionImpl.onPlayerCommandRequestOnHandler(controllerInfo, i2);
        if (iOnPlayerCommandRequestOnHandler != 0) {
            sendSessionResult(mediaSessionImpl, controllerInfo, i3, new SessionResult(iOnPlayerCommandRequestOnHandler));
        } else if (i2 != 27) {
            this.connectedControllersManager.addToCommandQueue(controllerInfo, i2, new ConnectedControllersManager.AsyncCommand() { // from class: androidx.media3.session.Q4
                @Override // androidx.media3.session.ConnectedControllersManager.AsyncCommand
                public final ListenableFuture run() {
                    return MediaSessionStub.lambda$queueSessionTaskWithPlayerCommandForControllerInfo$13(sessionTask, mediaSessionImpl, controllerInfo, i3);
                }
            });
        } else {
            mediaSessionImpl.callWithControllerForCurrentRequestSet(controllerInfo, new Runnable() { // from class: androidx.media3.session.O4
                @Override // java.lang.Runnable
                public final void run() {
                    sessionTask.run(mediaSessionImpl, controllerInfo, i3);
                }
            }).run();
            this.connectedControllersManager.addToCommandQueue(controllerInfo, i2, new ConnectedControllersManager.AsyncCommand() { // from class: androidx.media3.session.P4
                @Override // androidx.media3.session.ConnectedControllersManager.AsyncCommand
                public final ListenableFuture run() {
                    return Futures.immediateVoidFuture();
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$release$18(IMediaController iMediaController) {
        this.connectedControllersManager.removeController(iMediaController.asBinder());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$removeMediaItem$42(int i2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
        playerWrapper.removeMediaItem(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$removeMediaItems$43(int i2, int i3, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
        playerWrapper.removeMediaItems(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i3));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$replaceMediaItem$46(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, ImmutableList.of(mediaItem));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$replaceMediaItem$47(int i2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
        if (list.size() == 1) {
            playerWrapper.replaceMediaItem(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), (MediaItem) list.get(0));
        } else {
            playerWrapper.replaceMediaItems(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2 + 1), list);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$replaceMediaItems$48(ImmutableList immutableList, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, immutableList);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$replaceMediaItems$49(int i2, int i3, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
        playerWrapper.replaceMediaItems(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i3), list);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$search$69(String str, MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaLibrarySessionImpl.onSearchOnHandler(controllerInfo, str, libraryParams);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToDefaultPositionWithMediaItemIndex$21(int i2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
        playerWrapper.seekToDefaultPosition(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToWithMediaItemIndex$23(int i2, long j2, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
        playerWrapper.seekTo(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i2), j2);
    }

    private static /* synthetic */ void lambda$sendLibraryResultWhenReady$10(MediaSession.ControllerInfo controllerInfo, int i2, ListenableFuture listenableFuture) {
        LibraryResult libraryResultOfError;
        try {
            libraryResultOfError = (LibraryResult) Assertions.checkNotNull((LibraryResult) listenableFuture.get(), "LibraryResult must not be null");
        } catch (InterruptedException e2) {
            e = e2;
            Log.w(TAG, "Library operation failed", e);
            libraryResultOfError = LibraryResult.ofError(-1);
        } catch (CancellationException e3) {
            Log.w(TAG, "Library operation cancelled", e3);
            libraryResultOfError = LibraryResult.ofError(1);
        } catch (ExecutionException e4) {
            e = e4;
            Log.w(TAG, "Library operation failed", e);
            libraryResultOfError = LibraryResult.ofError(-1);
        }
        sendLibraryResult(controllerInfo, i2, libraryResultOfError);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$sendLibraryResultWhenReady$11(SessionTask sessionTask, MediaLibrarySessionImpl mediaLibrarySessionImpl, final MediaSession.ControllerInfo controllerInfo, final int i2) {
        return handleSessionTaskWhenReady(mediaLibrarySessionImpl, controllerInfo, i2, sessionTask, new Consumer() { // from class: androidx.media3.session.L4
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$sendSessionResultSuccess$1(ControllerPlayerTask controllerPlayerTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        if (mediaSessionImpl.isReleased()) {
            return Futures.immediateVoidFuture();
        }
        controllerPlayerTask.run(mediaSessionImpl.getPlayerWrapper(), controllerInfo);
        sendSessionResult(mediaSessionImpl, controllerInfo, i2, new SessionResult(0));
        return Futures.immediateVoidFuture();
    }

    /* JADX WARN: Removed duplicated region for block: B:13:0x0026  */
    /* JADX WARN: Removed duplicated region for block: B:14:0x0028  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static /* synthetic */ void lambda$sendSessionResultWhenReady$2(androidx.media3.session.MediaSessionImpl r2, androidx.media3.session.MediaSession.ControllerInfo r3, int r4, com.google.common.util.concurrent.ListenableFuture r5) {
        /*
            java.lang.String r0 = "MediaSessionStub"
            java.lang.Object r5 = r5.get()     // Catch: java.lang.InterruptedException -> L11 java.util.concurrent.ExecutionException -> L13 java.util.concurrent.CancellationException -> L15
            androidx.media3.session.SessionResult r5 = (androidx.media3.session.SessionResult) r5     // Catch: java.lang.InterruptedException -> L11 java.util.concurrent.ExecutionException -> L13 java.util.concurrent.CancellationException -> L15
            java.lang.String r1 = "SessionResult must not be null"
            java.lang.Object r5 = androidx.media3.common.util.Assertions.checkNotNull(r5, r1)     // Catch: java.lang.InterruptedException -> L11 java.util.concurrent.ExecutionException -> L13 java.util.concurrent.CancellationException -> L15
            androidx.media3.session.SessionResult r5 = (androidx.media3.session.SessionResult) r5     // Catch: java.lang.InterruptedException -> L11 java.util.concurrent.ExecutionException -> L13 java.util.concurrent.CancellationException -> L15
            goto L39
        L11:
            r5 = move-exception
            goto L17
        L13:
            r5 = move-exception
            goto L17
        L15:
            r5 = move-exception
            goto L2e
        L17:
            java.lang.String r1 = "Session operation failed"
            androidx.media3.common.util.Log.w(r0, r1, r5)
            androidx.media3.session.SessionResult r0 = new androidx.media3.session.SessionResult
            java.lang.Throwable r5 = r5.getCause()
            boolean r5 = r5 instanceof java.lang.UnsupportedOperationException
            if (r5 == 0) goto L28
            r5 = -6
            goto L29
        L28:
            r5 = -1
        L29:
            r0.<init>(r5)
            r5 = r0
            goto L39
        L2e:
            java.lang.String r1 = "Session operation cancelled"
            androidx.media3.common.util.Log.w(r0, r1, r5)
            androidx.media3.session.SessionResult r5 = new androidx.media3.session.SessionResult
            r0 = 1
            r5.<init>(r0)
        L39:
            sendSessionResult(r2, r3, r4, r5)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: androidx.media3.session.MediaSessionStub.lambda$sendSessionResultWhenReady$2(androidx.media3.session.MediaSessionImpl, androidx.media3.session.MediaSession$ControllerInfo, int, com.google.common.util.concurrent.ListenableFuture):void");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$sendSessionResultWhenReady$3(SessionTask sessionTask, final MediaSessionImpl mediaSessionImpl, final MediaSession.ControllerInfo controllerInfo, final int i2) {
        return handleSessionTaskWhenReady(mediaSessionImpl, controllerInfo, i2, sessionTask, new Consumer() { // from class: androidx.media3.session.F5
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setMediaItemWithResetPosition$30(MediaItem mediaItem, boolean z2, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, ImmutableList.of(mediaItem), z2 ? -1 : mediaSessionImpl.getPlayerWrapper().getCurrentMediaItemIndex(), z2 ? -9223372036854775807L : mediaSessionImpl.getPlayerWrapper().getCurrentPosition());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setMediaItemWithStartPosition$29(MediaItem mediaItem, long j2, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, ImmutableList.of(mediaItem), 0, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setMediaItemsWithResetPosition$31(List list, boolean z2, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, list, z2 ? -1 : mediaSessionImpl.getPlayerWrapper().getCurrentMediaItemIndex(), z2 ? -9223372036854775807L : mediaSessionImpl.getPlayerWrapper().getCurrentPosition());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setMediaItemsWithStartIndex$32(List list, int i2, long j2, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
        int currentMediaItemIndex = i2 == -1 ? mediaSessionImpl.getPlayerWrapper().getCurrentMediaItemIndex() : i2;
        if (i2 == -1) {
            j2 = mediaSessionImpl.getPlayerWrapper().getCurrentPosition();
        }
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, list, currentMediaItemIndex, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setRating$26(Rating rating, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onSetRatingOnHandler(controllerInfo, rating);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$setRatingWithMediaId$25(String str, Rating rating, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaSessionImpl.onSetRatingOnHandler(controllerInfo, str, rating);
    }

    private /* synthetic */ void lambda$setTrackSelectionParameters$65(TrackSelectionParameters trackSelectionParameters, PlayerWrapper playerWrapper) {
        playerWrapper.setTrackSelectionParameters(updateOverridesUsingUniqueTrackGroupIds(trackSelectionParameters));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$subscribe$71(String str, MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaLibrarySessionImpl.onSubscribeOnHandler(controllerInfo, str, libraryParams);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ ListenableFuture lambda$unsubscribe$72(String str, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
        return mediaLibrarySessionImpl.onUnsubscribeOnHandler(controllerInfo, str);
    }

    private int maybeCorrectMediaItemIndex(MediaSession.ControllerInfo controllerInfo, PlayerWrapper playerWrapper, int i2) {
        return (playerWrapper.isCommandAvailable(17) && !this.connectedControllersManager.isPlayerCommandAvailable(controllerInfo, 17) && this.connectedControllersManager.isPlayerCommandAvailable(controllerInfo, 16)) ? i2 + playerWrapper.getCurrentMediaItemIndex() : i2;
    }

    private <K extends MediaSessionImpl> void queueSessionTaskWithPlayerCommand(IMediaController iMediaController, int i2, int i3, SessionTask<ListenableFuture, K> sessionTask) {
        MediaSession.ControllerInfo controller = this.connectedControllersManager.getController(iMediaController.asBinder());
        if (controller != null) {
            queueSessionTaskWithPlayerCommandForControllerInfo(controller, i2, i3, sessionTask);
        }
    }

    private <K extends MediaSessionImpl> void queueSessionTaskWithPlayerCommandForControllerInfo(final MediaSession.ControllerInfo controllerInfo, final int i2, final int i3, final SessionTask<ListenableFuture, K> sessionTask) {
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            final MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.m5
                    @Override // java.lang.Runnable
                    public final void run() {
                        this.f2763b.lambda$queueSessionTaskWithPlayerCommandForControllerInfo$14(controllerInfo, i3, mediaSessionImpl, i2, sessionTask);
                    }
                });
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

    private static void sendLibraryResult(MediaSession.ControllerInfo controllerInfo, int i2, LibraryResult<?> libraryResult) {
        try {
            ((MediaSession.ControllerCb) Assertions.checkStateNotNull(controllerInfo.getControllerCb())).onLibraryResult(i2, libraryResult);
        } catch (RemoteException e2) {
            Log.w(TAG, "Failed to send result to browser " + controllerInfo, e2);
        }
    }

    private static <V, K extends MediaLibrarySessionImpl> SessionTask<ListenableFuture, K> sendLibraryResultWhenReady(final SessionTask<ListenableFuture, K> sessionTask) {
        return new SessionTask() { // from class: androidx.media3.session.y5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
                return MediaSessionStub.lambda$sendLibraryResultWhenReady$11(sessionTask, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i2);
            }
        };
    }

    private static void sendSessionResult(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2, SessionResult sessionResult) {
        try {
            ((MediaSession.ControllerCb) Assertions.checkStateNotNull(controllerInfo.getControllerCb())).onSessionResult(i2, sessionResult);
            mediaSessionImpl.triggerPlayerInfoUpdate();
        } catch (RemoteException e2) {
            Log.w(TAG, "Failed to send result to controller " + controllerInfo, e2);
        }
    }

    private static <K extends MediaSessionImpl> SessionTask<ListenableFuture, K> sendSessionResultSuccess(final Consumer<PlayerWrapper> consumer) {
        return sendSessionResultSuccess(new ControllerPlayerTask() { // from class: androidx.media3.session.x5
            @Override // androidx.media3.session.MediaSessionStub.ControllerPlayerTask
            public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
                consumer.accept(playerWrapper);
            }
        });
    }

    private static <K extends MediaSessionImpl> SessionTask<ListenableFuture, K> sendSessionResultWhenReady(final SessionTask<ListenableFuture, K> sessionTask) {
        return new SessionTask() { // from class: androidx.media3.session.z5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
                return MediaSessionStub.lambda$sendSessionResultWhenReady$3(sessionTask, mediaSessionImpl, controllerInfo, i2);
            }
        };
    }

    private TrackSelectionParameters updateOverridesUsingUniqueTrackGroupIds(TrackSelectionParameters trackSelectionParameters) {
        if (trackSelectionParameters.overrides.isEmpty()) {
            return trackSelectionParameters;
        }
        TrackSelectionParameters.Builder builderClearOverrides = trackSelectionParameters.buildUpon().clearOverrides();
        UnmodifiableIterator it = trackSelectionParameters.overrides.values().iterator();
        while (it.hasNext()) {
            TrackSelectionOverride trackSelectionOverride = (TrackSelectionOverride) it.next();
            TrackGroup trackGroup = (TrackGroup) this.trackGroupIdMap.inverse().get(trackSelectionOverride.mediaTrackGroup.id);
            if (trackGroup == null || trackSelectionOverride.mediaTrackGroup.length != trackGroup.length) {
                builderClearOverrides.addOverride(trackSelectionOverride);
            } else {
                builderClearOverrides.addOverride(new TrackSelectionOverride(trackGroup, trackSelectionOverride.trackIndices));
            }
        }
        return builderClearOverrides.build();
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItem(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.q5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$addMediaItem$34(mediaItemFromBundle, mediaSessionImpl, controllerInfo, i3);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.r5
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    playerWrapper.addMediaItems(list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItemWithIndex(@Nullable IMediaController iMediaController, int i2, final int i3, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null || i3 < 0) {
            return;
        }
        try {
            final MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.R4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
                    return MediaSessionStub.lambda$addMediaItemWithIndex$36(mediaItemFromBundle, mediaSessionImpl, controllerInfo, i4);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.S4
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    this.f2479a.lambda$addMediaItemWithIndex$37(i3, playerWrapper, controllerInfo, list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItems(@Nullable IMediaController iMediaController, int i2, @Nullable IBinder iBinder) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        try {
            final ImmutableList immutableListFromBundleList = BundleCollectionUtil.fromBundleList(new C0254f(), BundleListRetriever.getList(iBinder));
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.o5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$addMediaItems$38(immutableListFromBundleList, mediaSessionImpl, controllerInfo, i3);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.p5
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    playerWrapper.addMediaItems(list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItemsWithIndex(@Nullable IMediaController iMediaController, int i2, final int i3, @Nullable IBinder iBinder) {
        if (iMediaController == null || iBinder == null || i3 < 0) {
            return;
        }
        try {
            final ImmutableList immutableListFromBundleList = BundleCollectionUtil.fromBundleList(new C0254f(), BundleListRetriever.getList(iBinder));
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.a5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
                    return MediaSessionStub.lambda$addMediaItemsWithIndex$40(immutableListFromBundleList, mediaSessionImpl, controllerInfo, i4);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.b5
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    this.f2608a.lambda$addMediaItemsWithIndex$41(i3, playerWrapper, controllerInfo, list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void clearMediaItems(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultSuccess(new D5()));
    }

    public void connect(@Nullable final IMediaController iMediaController, @Nullable final MediaSession.ControllerInfo controllerInfo) {
        if (iMediaController == null || controllerInfo == null) {
            SessionUtil.disconnectIMediaController(iMediaController);
            return;
        }
        final MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        if (mediaSessionImpl == null || mediaSessionImpl.isReleased()) {
            SessionUtil.disconnectIMediaController(iMediaController);
        } else {
            this.pendingControllers.add(controllerInfo);
            Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.s5
                @Override // java.lang.Runnable
                public final void run() throws Throwable {
                    this.f2855b.lambda$connect$17(controllerInfo, mediaSessionImpl, iMediaController);
                }
            });
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void decreaseDeviceVolume(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 26, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void decreaseDeviceVolumeWithFlags(@Nullable IMediaController iMediaController, int i2, int i3) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 34, sendSessionResultSuccess(new C0274h5(i3)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void flushCommandQueue(@Nullable IMediaController iMediaController) {
        if (iMediaController == null) {
            return;
        }
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                final MediaSession.ControllerInfo controller = this.connectedControllersManager.getController(iMediaController.asBinder());
                if (controller != null) {
                    Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.e5
                        @Override // java.lang.Runnable
                        public final void run() {
                            this.f2652b.lambda$flushCommandQueue$64(controller);
                        }
                    });
                }
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

    PlayerInfo generateAndCacheUniqueTrackGroupIds(PlayerInfo playerInfo) {
        ImmutableList groups = playerInfo.currentTracks.getGroups();
        ImmutableList.Builder builder = ImmutableList.builder();
        ImmutableBiMap.Builder builder2 = ImmutableBiMap.builder();
        for (int i2 = 0; i2 < groups.size(); i2++) {
            Tracks.Group group = (Tracks.Group) groups.get(i2);
            TrackGroup mediaTrackGroup = group.getMediaTrackGroup();
            String strGenerateUniqueTrackGroupId = (String) this.trackGroupIdMap.get(mediaTrackGroup);
            if (strGenerateUniqueTrackGroupId == null) {
                strGenerateUniqueTrackGroupId = generateUniqueTrackGroupId(mediaTrackGroup);
            }
            builder2.put(mediaTrackGroup, strGenerateUniqueTrackGroupId);
            builder.add(group.copyWithId(strGenerateUniqueTrackGroupId));
        }
        this.trackGroupIdMap = builder2.buildOrThrow();
        PlayerInfo playerInfoCopyWithCurrentTracks = playerInfo.copyWithCurrentTracks(new Tracks(builder.build()));
        if (playerInfoCopyWithCurrentTracks.trackSelectionParameters.overrides.isEmpty()) {
            return playerInfoCopyWithCurrentTracks;
        }
        TrackSelectionParameters.Builder builderClearOverrides = playerInfoCopyWithCurrentTracks.trackSelectionParameters.buildUpon().clearOverrides();
        UnmodifiableIterator it = playerInfoCopyWithCurrentTracks.trackSelectionParameters.overrides.values().iterator();
        while (it.hasNext()) {
            TrackSelectionOverride trackSelectionOverride = (TrackSelectionOverride) it.next();
            TrackGroup trackGroup = trackSelectionOverride.mediaTrackGroup;
            String str = (String) this.trackGroupIdMap.get(trackGroup);
            if (str != null) {
                builderClearOverrides.addOverride(new TrackSelectionOverride(trackGroup.copyWithId(str), trackSelectionOverride.trackIndices));
            } else {
                builderClearOverrides.addOverride(trackSelectionOverride);
            }
        }
        return playerInfoCopyWithCurrentTracks.copyWithTrackSelectionParameters(builderClearOverrides.build());
    }

    @Override // androidx.media3.session.IMediaSession
    public void getChildren(@Nullable IMediaController iMediaController, int i2, @Nullable final String str, final int i3, final int i4, @Nullable Bundle bundle) {
        final MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getChildren(): Ignoring empty parentId");
            return;
        }
        if (i3 < 0) {
            Log.w(TAG, "getChildren(): Ignoring negative page");
            return;
        }
        if (i4 < 1) {
            Log.w(TAG, "getChildren(): Ignoring pageSize less than 1");
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e2);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_GET_CHILDREN, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.D4
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i5) {
                return MediaSessionStub.lambda$getChildren$68(str, i3, i4, libraryParamsFromBundle, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i5);
            }
        }));
    }

    public ConnectedControllersManager<IBinder> getConnectedControllersManager() {
        return this.connectedControllersManager;
    }

    @Override // androidx.media3.session.IMediaSession
    public void getItem(@Nullable IMediaController iMediaController, int i2, @Nullable final String str) {
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getItem(): Ignoring empty mediaId");
        } else {
            dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_GET_ITEM, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.i5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$getItem$67(str, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i3);
                }
            }));
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void getLibraryRoot(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        final MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e2);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_GET_LIBRARY_ROOT, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.w5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                return MediaSessionStub.lambda$getLibraryRoot$66(libraryParamsFromBundle, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i3);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void getSearchResult(@Nullable IMediaController iMediaController, int i2, @Nullable final String str, final int i3, final int i4, @Nullable Bundle bundle) {
        final MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getSearchResult(): Ignoring empty query");
            return;
        }
        if (i3 < 0) {
            Log.w(TAG, "getSearchResult(): Ignoring negative page");
            return;
        }
        if (i4 < 1) {
            Log.w(TAG, "getSearchResult(): Ignoring pageSize less than 1");
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e2);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_GET_SEARCH_RESULT, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.t5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i5) {
                return MediaSessionStub.lambda$getSearchResult$70(str, i3, i4, libraryParamsFromBundle, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i5);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void increaseDeviceVolume(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 26, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void increaseDeviceVolumeWithFlags(@Nullable IMediaController iMediaController, int i2, int i3) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 34, sendSessionResultSuccess(new C0274h5(i3)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void moveMediaItem(@Nullable IMediaController iMediaController, int i2, int i3, int i4) {
        if (iMediaController == null || i3 < 0 || i4 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultSuccess(new C0302l5(i3, i4)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void moveMediaItems(@Nullable IMediaController iMediaController, int i2, final int i3, final int i4, final int i5) {
        if (iMediaController == null || i3 < 0 || i4 < i3 || i5 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.f5
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void onControllerResult(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            SessionResult sessionResultFromBundle = SessionResult.fromBundle(bundle);
            long jClearCallingIdentity = Binder.clearCallingIdentity();
            try {
                SequencedFutureManager sequencedFutureManager = this.connectedControllersManager.getSequencedFutureManager(iMediaController.asBinder());
                if (sequencedFutureManager == null) {
                    return;
                }
                sequencedFutureManager.setFutureResult(i2, sessionResultFromBundle);
            } finally {
                Binder.restoreCallingIdentity(jClearCallingIdentity);
            }
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for SessionResult", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void onCustomCommand(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle, @Nullable final Bundle bundle2) {
        if (iMediaController == null || bundle == null || bundle2 == null) {
            return;
        }
        try {
            final SessionCommand sessionCommandFromBundle = SessionCommand.fromBundle(bundle);
            dispatchSessionTaskWithSessionCommand(iMediaController, i2, sessionCommandFromBundle, sendSessionResultWhenReady(new SessionTask() { // from class: androidx.media3.session.X4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$onCustomCommand$24(sessionCommandFromBundle, bundle2, mediaSessionImpl, controllerInfo, i3);
                }
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for SessionCommand", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void pause(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        pauseForControllerInfo(controller, i2);
    }

    public void pauseForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 1, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void play(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        playForControllerInfo(controller, i2);
    }

    public void playForControllerInfo(final MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 1, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.c5
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void prepare(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 2, sendSessionResultSuccess(new D5()));
    }

    public void release() {
        for (MediaSession.ControllerInfo controllerInfo : this.connectedControllersManager.getConnectedControllers()) {
            this.connectedControllersManager.removeController(controllerInfo);
            MediaSession.ControllerCb controllerCb = controllerInfo.getControllerCb();
            if (controllerCb != null) {
                controllerCb.onDisconnected(0);
            }
        }
        Iterator<MediaSession.ControllerInfo> it = this.pendingControllers.iterator();
        while (it.hasNext()) {
            MediaSession.ControllerCb controllerCb2 = it.next().getControllerCb();
            if (controllerCb2 != null) {
                controllerCb2.onDisconnected(0);
            }
        }
        this.pendingControllers.clear();
        this.sessionImpl.clear();
    }

    @Override // androidx.media3.session.IMediaSession
    public void removeMediaItem(@Nullable IMediaController iMediaController, int i2, final int i3) {
        if (iMediaController == null || i3 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultSuccess(new ControllerPlayerTask() { // from class: androidx.media3.session.K5
            @Override // androidx.media3.session.MediaSessionStub.ControllerPlayerTask
            public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
                this.f2367a.lambda$removeMediaItem$42(i3, playerWrapper, controllerInfo);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void removeMediaItems(@Nullable IMediaController iMediaController, int i2, final int i3, final int i4) {
        if (iMediaController == null || i3 < 0 || i4 < i3) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultSuccess(new ControllerPlayerTask() { // from class: androidx.media3.session.A4
            @Override // androidx.media3.session.MediaSessionStub.ControllerPlayerTask
            public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
                this.f2249a.lambda$removeMediaItems$43(i3, i4, playerWrapper, controllerInfo);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void replaceMediaItem(@Nullable IMediaController iMediaController, int i2, final int i3, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null || i3 < 0) {
            return;
        }
        try {
            final MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.U4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
                    return MediaSessionStub.lambda$replaceMediaItem$46(mediaItemFromBundle, mediaSessionImpl, controllerInfo, i4);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.V4
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    this.f2519a.lambda$replaceMediaItem$47(i3, playerWrapper, controllerInfo, list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void replaceMediaItems(@Nullable IMediaController iMediaController, int i2, final int i3, final int i4, @Nullable IBinder iBinder) {
        if (iMediaController == null || iBinder == null || i3 < 0 || i4 < i3) {
            return;
        }
        try {
            final ImmutableList immutableListFromBundleList = BundleCollectionUtil.fromBundleList(new C0254f(), BundleListRetriever.getList(iBinder));
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new SessionTask() { // from class: androidx.media3.session.F4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i5) {
                    return MediaSessionStub.lambda$replaceMediaItems$48(immutableListFromBundleList, mediaSessionImpl, controllerInfo, i5);
                }
            }, new MediaItemPlayerTask() { // from class: androidx.media3.session.G4
                @Override // androidx.media3.session.MediaSessionStub.MediaItemPlayerTask
                public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List list) {
                    this.f2318a.lambda$replaceMediaItems$49(i3, i4, playerWrapper, controllerInfo, list);
                }
            })));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void search(@Nullable IMediaController iMediaController, int i2, @Nullable final String str, @Nullable Bundle bundle) {
        final MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "search(): Ignoring empty query");
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e2);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_SEARCH, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.J5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                return MediaSessionStub.lambda$search$69(str, libraryParamsFromBundle, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i3);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekBack(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        seekBackForControllerInfo(controller, i2);
    }

    public void seekBackForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 11, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekForward(IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        seekForwardForControllerInfo(controller, i2);
    }

    public void seekForwardForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 12, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekTo(@Nullable IMediaController iMediaController, int i2, final long j2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 5, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.I5
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToDefaultPosition(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 4, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToDefaultPositionWithMediaItemIndex(@Nullable IMediaController iMediaController, int i2, final int i3) {
        if (iMediaController == null || i3 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 10, sendSessionResultSuccess(new ControllerPlayerTask() { // from class: androidx.media3.session.H4
            @Override // androidx.media3.session.MediaSessionStub.ControllerPlayerTask
            public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
                this.f2332a.lambda$seekToDefaultPositionWithMediaItemIndex$21(i3, playerWrapper, controllerInfo);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToNext(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        seekToNextForControllerInfo(controller, i2);
    }

    public void seekToNextForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 9, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToNextMediaItem(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 8, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToPrevious(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        seekToPreviousForControllerInfo(controller, i2);
    }

    public void seekToPreviousForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 7, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToPreviousMediaItem(@Nullable IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 6, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekToWithMediaItemIndex(@Nullable IMediaController iMediaController, int i2, final int i3, final long j2) {
        if (iMediaController == null || i3 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 10, sendSessionResultSuccess(new ControllerPlayerTask() { // from class: androidx.media3.session.M4
            @Override // androidx.media3.session.MediaSessionStub.ControllerPlayerTask
            public final void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
                this.f2392a.lambda$seekToWithMediaItemIndex$23(i3, j2, playerWrapper, controllerInfo);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setAudioAttributes(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle, final boolean z2) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final AudioAttributes audioAttributesFromBundle = AudioAttributes.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 35, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.n5
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for AudioAttributes", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceMuted(@Nullable IMediaController iMediaController, int i2, boolean z2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 26, sendSessionResultSuccess(new I4(z2)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceMutedWithFlags(@Nullable IMediaController iMediaController, int i2, final boolean z2, final int i3) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 34, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.A5
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceVolume(@Nullable IMediaController iMediaController, int i2, int i3) {
        if (iMediaController == null || i3 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 25, sendSessionResultSuccess(new C0274h5(i3)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceVolumeWithFlags(@Nullable IMediaController iMediaController, int i2, int i3, int i4) {
        if (iMediaController == null || i3 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 33, sendSessionResultSuccess(new C0302l5(i3, i4)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItem(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        setMediaItemWithResetPosition(iMediaController, i2, bundle, true);
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemWithResetPosition(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle, final boolean z2) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 31, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new SessionTask() { // from class: androidx.media3.session.Z4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$setMediaItemWithResetPosition$30(mediaItemFromBundle, z2, mediaSessionImpl, controllerInfo, i3);
                }
            }, new N5())));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemWithStartPosition(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle, final long j2) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 31, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new SessionTask() { // from class: androidx.media3.session.C5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$setMediaItemWithStartPosition$29(mediaItemFromBundle, j2, mediaSessionImpl, controllerInfo, i3);
                }
            }, new N5())));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItems(@Nullable IMediaController iMediaController, int i2, @Nullable IBinder iBinder) {
        setMediaItemsWithResetPosition(iMediaController, i2, iBinder, true);
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemsWithResetPosition(@Nullable IMediaController iMediaController, int i2, @Nullable IBinder iBinder, final boolean z2) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        try {
            final ImmutableList immutableListFromBundleList = BundleCollectionUtil.fromBundleList(new C0254f(), BundleListRetriever.getList(iBinder));
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new SessionTask() { // from class: androidx.media3.session.M5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$setMediaItemsWithResetPosition$31(immutableListFromBundleList, z2, mediaSessionImpl, controllerInfo, i3);
                }
            }, new N5())));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemsWithStartIndex(@Nullable IMediaController iMediaController, int i2, @Nullable IBinder iBinder, final int i3, final long j2) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        if (i3 == -1 || i3 >= 0) {
            try {
                final ImmutableList immutableListFromBundleList = BundleCollectionUtil.fromBundleList(new C0254f(), BundleListRetriever.getList(iBinder));
                queueSessionTaskWithPlayerCommand(iMediaController, i2, 20, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new SessionTask() { // from class: androidx.media3.session.g5
                    @Override // androidx.media3.session.MediaSessionStub.SessionTask
                    public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i4) {
                        return MediaSessionStub.lambda$setMediaItemsWithStartIndex$32(immutableListFromBundleList, i3, j2, mediaSessionImpl, controllerInfo, i4);
                    }
                }, new N5())));
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e2);
            }
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlayWhenReady(@Nullable IMediaController iMediaController, int i2, boolean z2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 1, sendSessionResultSuccess(new I4(z2)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlaybackParameters(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final PlaybackParameters playbackParametersFromBundle = PlaybackParameters.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 13, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.Y4
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for PlaybackParameters", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlaybackSpeed(@Nullable IMediaController iMediaController, int i2, float f2) {
        if (iMediaController == null || f2 <= 0.0f) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 13, sendSessionResultSuccess(new K4(f2)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlaylistMetadata(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final MediaMetadata mediaMetadataFromBundle = MediaMetadata.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 19, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.B5
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaMetadata", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setRating(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final Rating ratingFromBundle = Rating.fromBundle(bundle);
            dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_SESSION_SET_RATING, sendSessionResultWhenReady(new SessionTask() { // from class: androidx.media3.session.B4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$setRating$26(ratingFromBundle, mediaSessionImpl, controllerInfo, i3);
                }
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for Rating", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setRatingWithMediaId(@Nullable IMediaController iMediaController, int i2, @Nullable final String str, @Nullable Bundle bundle) {
        if (iMediaController == null || str == null || bundle == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "setRatingWithMediaId(): Ignoring empty mediaId");
            return;
        }
        try {
            final Rating ratingFromBundle = Rating.fromBundle(bundle);
            dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_SESSION_SET_RATING, sendSessionResultWhenReady(new SessionTask() { // from class: androidx.media3.session.j5
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$setRatingWithMediaId$25(str, ratingFromBundle, mediaSessionImpl, controllerInfo, i3);
                }
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for Rating", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setRepeatMode(@Nullable IMediaController iMediaController, int i2, int i3) {
        if (iMediaController == null) {
            return;
        }
        if (i3 == 2 || i3 == 0 || i3 == 1) {
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 15, sendSessionResultSuccess(new C0274h5(i3)));
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setShuffleModeEnabled(@Nullable IMediaController iMediaController, int i2, boolean z2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 14, sendSessionResultSuccess(new I4(z2)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setTrackSelectionParameters(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            final TrackSelectionParameters trackSelectionParametersFromBundle = TrackSelectionParameters.fromBundle(bundle);
            queueSessionTaskWithPlayerCommand(iMediaController, i2, 29, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.W4
            }));
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for TrackSelectionParameters", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setVideoSurface(@Nullable IMediaController iMediaController, int i2, @Nullable final Surface surface) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 27, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.v5
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setVolume(@Nullable IMediaController iMediaController, int i2, float f2) {
        if (iMediaController == null || f2 < 0.0f || f2 > 1.0f) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i2, 24, sendSessionResultSuccess(new K4(f2)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void stop(@Nullable IMediaController iMediaController, int i2) {
        MediaSession.ControllerInfo controller;
        if (iMediaController == null || (controller = this.connectedControllersManager.getController(iMediaController.asBinder())) == null) {
            return;
        }
        stopForControllerInfo(controller, i2);
    }

    public void stopForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i2) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i2, 3, sendSessionResultSuccess(new D5()));
    }

    @Override // androidx.media3.session.IMediaSession
    public void subscribe(@Nullable IMediaController iMediaController, int i2, @Nullable final String str, @Nullable Bundle bundle) {
        final MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "subscribe(): Ignoring empty parentId");
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e2) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e2);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_SUBSCRIBE, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.E5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                return MediaSessionStub.lambda$subscribe$71(str, libraryParamsFromBundle, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i3);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void unsubscribe(@Nullable IMediaController iMediaController, int i2, @Nullable final String str) {
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "unsubscribe(): Ignoring empty parentId");
        } else {
            dispatchSessionTaskWithSessionCommand(iMediaController, i2, SessionCommand.COMMAND_CODE_LIBRARY_UNSUBSCRIBE, sendLibraryResultWhenReady(new SessionTask() { // from class: androidx.media3.session.C4
                @Override // androidx.media3.session.MediaSessionStub.SessionTask
                public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
                    return MediaSessionStub.lambda$unsubscribe$72(str, (MediaLibrarySessionImpl) mediaSessionImpl, controllerInfo, i3);
                }
            }));
        }
    }

    private <K extends MediaSessionImpl> void dispatchSessionTaskWithSessionCommand(IMediaController iMediaController, int i2, SessionCommand sessionCommand, SessionTask<ListenableFuture, K> sessionTask) {
        dispatchSessionTaskWithSessionCommand(iMediaController, i2, sessionCommand, 0, sessionTask);
    }

    private static <K extends MediaSessionImpl> SessionTask<ListenableFuture, K> sendSessionResultSuccess(final ControllerPlayerTask controllerPlayerTask) {
        return new SessionTask() { // from class: androidx.media3.session.L5
            @Override // androidx.media3.session.MediaSessionStub.SessionTask
            public final Object run(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i2) {
                return MediaSessionStub.lambda$sendSessionResultSuccess$1(controllerPlayerTask, mediaSessionImpl, controllerInfo, i2);
            }
        };
    }

    private <K extends MediaSessionImpl> void dispatchSessionTaskWithSessionCommand(IMediaController iMediaController, final int i2, @Nullable final SessionCommand sessionCommand, final int i3, final SessionTask<ListenableFuture, K> sessionTask) {
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            final MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                final MediaSession.ControllerInfo controller = this.connectedControllersManager.getController(iMediaController.asBinder());
                if (controller == null) {
                    return;
                }
                Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.k5
                    @Override // java.lang.Runnable
                    public final void run() {
                        this.f2722b.lambda$dispatchSessionTaskWithSessionCommand$15(controller, sessionCommand, mediaSessionImpl, i2, i3, sessionTask);
                    }
                });
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void connect(@Nullable IMediaController iMediaController, int i2, @Nullable Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            ConnectionRequest connectionRequestFromBundle = ConnectionRequest.fromBundle(bundle);
            int callingUid = Binder.getCallingUid();
            int callingPid = Binder.getCallingPid();
            long jClearCallingIdentity = Binder.clearCallingIdentity();
            if (callingPid == 0) {
                callingPid = connectionRequestFromBundle.pid;
            }
            try {
                MediaSessionManager.RemoteUserInfo remoteUserInfo = new MediaSessionManager.RemoteUserInfo(connectionRequestFromBundle.packageName, callingPid, callingUid);
                MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
                boolean z2 = mediaSessionImpl != null && MediaSessionManager.getSessionManager(mediaSessionImpl.getContext()).isTrustedForMediaControl(remoteUserInfo);
                int i3 = connectionRequestFromBundle.libraryVersion;
                int i4 = connectionRequestFromBundle.controllerInterfaceVersion;
                connect(iMediaController, new MediaSession.ControllerInfo(remoteUserInfo, i3, i4, z2, new Controller2Cb(iMediaController, i4), connectionRequestFromBundle.connectionHints, connectionRequestFromBundle.maxCommandsForMediaItems));
                Binder.restoreCallingIdentity(jClearCallingIdentity);
            } catch (Throwable th) {
                Binder.restoreCallingIdentity(jClearCallingIdentity);
                throw th;
            }
        } catch (RuntimeException e2) {
            Log.w(TAG, "Ignoring malformed Bundle for ConnectionRequest", e2);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void release(@Nullable final IMediaController iMediaController, int i2) {
        if (iMediaController == null) {
            return;
        }
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.E4
                    @Override // java.lang.Runnable
                    public final void run() {
                        this.f2292b.lambda$release$18(iMediaController);
                    }
                });
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }
}