package androidx.media3.session;

import android.app.PendingIntent;
import android.graphics.Canvas;
import android.graphics.Rect;
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 android.view.SurfaceHolder;
import androidx.media3.common.AudioAttributes;
import androidx.media3.common.BundleListRetriever;
import androidx.media3.common.C;
import androidx.media3.common.MediaItem;
import androidx.media3.common.MediaLibraryInfo;
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.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 defpackage.bj4;
import defpackage.if7;
import defpackage.jt5;
import defpackage.ks3;
import defpackage.o96;
import defpackage.om8;
import defpackage.p7a;
import defpackage.rq6;
import defpackage.si4;
import defpackage.sma;
import defpackage.zb5;
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 = 8;
    private final ConnectedControllersManager<IBinder> connectedControllersManager;
    private int nextUniqueTrackGroupIdPrefix;
    private final WeakReference<MediaSessionImpl> sessionImpl;

    @rq6
    private SurfaceHolderWithSize surfaceHolderWithSize;
    private final Set<MediaSession.ControllerInfo> pendingControllers = Collections.synchronizedSet(new HashSet());
    private si4<TrackGroup, String> trackGroupIdMap = si4.q();

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

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

        public boolean equals(@rq6 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 Objects.hash(getCallbackBinder());
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        @Override // androidx.media3.session.MediaSession.ControllerCb
        public void sendCustomCommandProgressUpdate(int i, SessionCommand sessionCommand, Bundle bundle, Bundle bundle2) throws RemoteException {
            this.iController.onCustomCommandProgressUpdate(i, sessionCommand.toBundle(), bundle, bundle2);
        }

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

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

    public interface ControllerPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo);
    }

    public interface MediaItemPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo, List<MediaItem> list);
    }

    public interface MediaItemsWithStartPositionPlayerTask {
        void run(PlayerWrapper playerWrapper, MediaSession.MediaItemsWithStartPosition mediaItemsWithStartPosition);
    }

    public static class ProgressReporter implements MediaSession.ProgressReporter {
        private final SessionCommand command;
        private final MediaSession.ControllerInfo controller;
        private final int customCommandFutureSequence;
        private final Bundle extras;

        @rq6
        private zb5<SessionResult> future;
        private final MediaSessionImpl session;

        public ProgressReporter(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i, SessionCommand sessionCommand, Bundle bundle) {
            this.session = mediaSessionImpl;
            this.controller = controllerInfo;
            this.customCommandFutureSequence = i;
            this.command = sessionCommand;
            this.extras = bundle;
        }

        @Override // androidx.media3.session.MediaSession.ProgressReporter
        public void sendProgressUpdate(Bundle bundle) {
            zb5<SessionResult> zb5Var = this.future;
            if ((zb5Var == null || !zb5Var.isDone()) && !this.session.isReleased()) {
                this.session.sendCustomCommandProgressUpdate(this.controller, this.customCommandFutureSequence, this.command, this.extras, bundle);
            }
        }

        public void setFuture(zb5<SessionResult> zb5Var) {
            this.future = zb5Var;
        }
    }

    public interface SessionTask<T, K extends MediaSessionImpl> {
        T run(K k, MediaSession.ControllerInfo controllerInfo, int i);
    }

    @sma
    public static class SurfaceHolderWithSize implements SurfaceHolder {

        @rq6
        private SurfaceHolder.Callback callback;
        private final Surface surface;
        private final Rect surfaceFrame;

        public SurfaceHolderWithSize(Surface surface) {
            this.surfaceFrame = new Rect();
            this.surface = surface;
        }

        @Override // android.view.SurfaceHolder
        public void addCallback(SurfaceHolder.Callback callback) {
            this.callback = callback;
        }

        @Override // android.view.SurfaceHolder
        public Surface getSurface() {
            return this.surface;
        }

        @Override // android.view.SurfaceHolder
        public Rect getSurfaceFrame() {
            return this.surfaceFrame;
        }

        @Override // android.view.SurfaceHolder
        public boolean isCreating() {
            return false;
        }

        @Override // android.view.SurfaceHolder
        public Canvas lockCanvas() {
            throw new UnsupportedOperationException();
        }

        @Override // android.view.SurfaceHolder
        public void removeCallback(SurfaceHolder.Callback callback) {
            if (this.callback == callback) {
                this.callback = null;
            }
        }

        @Override // android.view.SurfaceHolder
        public void setFixedSize(int i, int i2) {
            this.surfaceFrame.set(0, 0, i, i2);
            SurfaceHolder.Callback callback = this.callback;
            if (callback != null) {
                callback.surfaceChanged(this, 1, i, i2);
            }
        }

        @Override // android.view.SurfaceHolder
        public void setFormat(int i) {
        }

        @Override // android.view.SurfaceHolder
        public void setKeepScreenOn(boolean z) {
        }

        @Override // android.view.SurfaceHolder
        public void setSizeFromLayout() {
        }

        @Override // android.view.SurfaceHolder
        public void setType(int i) {
        }

        @Override // android.view.SurfaceHolder
        public void unlockCanvasAndPost(Canvas canvas) {
        }

        @Override // android.view.SurfaceHolder
        public Canvas lockCanvas(Rect rect) {
            throw new UnsupportedOperationException();
        }

        public SurfaceHolderWithSize(Surface surface, int i, int i2) {
            Rect rect = new Rect();
            this.surfaceFrame = rect;
            this.surface = surface;
            rect.set(0, 0, i, i2);
        }
    }

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

    private void dispatchCustomCommandAsPredefinedCommand(final IMediaController iMediaController, final int i, final SessionCommand sessionCommand) {
        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) {
                    Binder.restoreCallingIdentity(jClearCallingIdentity);
                } else {
                    Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.b0
                        @Override // java.lang.Runnable
                        public final void run() {
                            this.a.lambda$dispatchCustomCommandAsPredefinedCommand$27(controller, sessionCommand, mediaSessionImpl, i, iMediaController);
                        }
                    });
                    Binder.restoreCallingIdentity(jClearCallingIdentity);
                }
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

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

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

    private static <K extends MediaSessionImpl> SessionTask<zb5<SessionResult>, K> handleMediaItemsWhenReady(SessionTask<zb5<List<MediaItem>>, K> sessionTask, MediaItemPlayerTask mediaItemPlayerTask) {
        return new j(sessionTask, mediaItemPlayerTask, 22);
    }

    private static <K extends MediaSessionImpl> SessionTask<zb5<SessionResult>, K> handleMediaItemsWithStartPositionWhenReady(SessionTask<zb5<MediaSession.MediaItemsWithStartPosition>, K> sessionTask, MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask) {
        return new j(sessionTask, mediaItemsWithStartPositionPlayerTask, 20);
    }

    private static <T, K extends MediaSessionImpl> zb5<Void> handleSessionTaskWhenReady(K k, MediaSession.ControllerInfo controllerInfo, int i, SessionTask<zb5<T>, K> sessionTask, Consumer<zb5<T>> consumer) {
        if (k.isReleased()) {
            return ks3.e();
        }
        zb5<T> zb5VarRun = sessionTask.run(k, controllerInfo, i);
        om8 om8Var = new om8();
        zb5VarRun.addListener(new d(k, om8Var, consumer, zb5VarRun, 8), o96.a());
        return om8Var;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$addMediaItem$37(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, bj4.r(mediaItem));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$addMediaItemWithIndex$39(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, bj4.r(mediaItem));
    }

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

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

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

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

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$connect$17(MediaSession.ControllerInfo controllerInfo, MediaSessionImpl mediaSessionImpl, IMediaController iMediaController) throws Throwable {
        IMediaController iMediaController2;
        Player.Commands commandsCreatePlayerCommandsForCustomErrorState;
        boolean z = false;
        try {
            this.pendingControllers.remove(controllerInfo);
            if (mediaSessionImpl.isReleased()) {
                SessionUtil.disconnectIMediaController(iMediaController);
                return;
            }
            Controller2Cb controller2Cb = (Controller2Cb) controllerInfo.getControllerCb();
            controller2Cb.getClass();
            IBinder callbackBinder = controller2Cb.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) {
                commandsCreatePlayerCommandsForCustomErrorState = connectionResultOnConnectOnHandler.availablePlayerCommands;
            } else {
                this.connectedControllersManager.setPlaybackException(controllerInfo, playbackException, connectionResultOnConnectOnHandler.availablePlayerCommands);
                playerInfo = MediaSessionImpl.createPlayerInfoForCustomPlaybackException(playerInfo, playbackException);
                commandsCreatePlayerCommandsForCustomErrorState = MediaSessionImpl.createPlayerCommandsForCustomErrorState(connectionResultOnConnectOnHandler.availablePlayerCommands);
                commandsCreatePlayerCommandsForCustomErrorState.getClass();
            }
            Player.Commands commands = commandsCreatePlayerCommandsForCustomErrorState;
            PlayerInfo playerInfoGenerateAndCacheUniqueTrackGroupIds = generateAndCacheUniqueTrackGroupIds(playerInfo);
            MediaSession.Token platformToken = mediaSessionImpl.getPlatformToken();
            PendingIntent sessionActivity = connectionResultOnConnectOnHandler.sessionActivity;
            if (sessionActivity == null) {
                sessionActivity = mediaSessionImpl.getSessionActivity();
            }
            bj4<CommandButton> customLayout = connectionResultOnConnectOnHandler.customLayout;
            if (customLayout == null) {
                customLayout = mediaSessionImpl.getCustomLayout();
            }
            bj4<CommandButton> mediaButtonPreferences = connectionResultOnConnectOnHandler.mediaButtonPreferences;
            if (mediaButtonPreferences == null) {
                mediaButtonPreferences = mediaSessionImpl.getMediaButtonPreferences();
            }
            bj4<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();
            }
            iMediaController2 = iMediaController;
            try {
                ConnectionState connectionState = new ConnectionState(MediaLibraryInfo.VERSION_INT, 8, this, sessionActivity, customLayout, mediaButtonPreferences, commandButtonsForMediaItems, sessionCommands, commands, availableCommands, extras, sessionExtras, playerInfoGenerateAndCacheUniqueTrackGroupIds, platformToken);
                if (mediaSessionImpl.isReleased()) {
                    SessionUtil.disconnectIMediaController(iMediaController2);
                    return;
                }
                try {
                    iMediaController2.onConnected(sequencedFutureManager.obtainNextSequenceNumber(), iMediaController2 instanceof MediaControllerStub ? connectionState.toBundleInProcess() : connectionState.toBundleForRemoteProcess(controllerInfo.getInterfaceVersion()));
                    z = true;
                } catch (RemoteException unused) {
                }
                if (z) {
                    mediaSessionImpl.onPostConnectOnHandler(controllerInfo);
                }
                if (z) {
                    return;
                }
                SessionUtil.disconnectIMediaController(iMediaController2);
            } catch (Throwable th) {
                th = th;
                if (!z) {
                    SessionUtil.disconnectIMediaController(iMediaController2);
                }
                throw th;
            }
        } catch (Throwable th2) {
            th = th2;
            iMediaController2 = iMediaController;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static zb5 lambda$dispatchCustomCommandAsPredefinedCommand$25(CommandButton commandButton, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        Object obj = commandButton.parameter;
        obj.getClass();
        return mediaSessionImpl.onSetRatingOnHandler(controllerInfo, (Rating) obj);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$dispatchCustomCommandAsPredefinedCommand$27(MediaSession.ControllerInfo controllerInfo, SessionCommand sessionCommand, MediaSessionImpl mediaSessionImpl, int i, IMediaController iMediaController) {
        if (this.connectedControllersManager.isConnected(controllerInfo)) {
            try {
                CommandButton commandButtonConvertFromPredefinedCustomCommand = CommandButton.convertFromPredefinedCustomCommand(sessionCommand);
                if (!commandButtonConvertFromPredefinedCustomCommand.canExecuteAction()) {
                    Log.w(TAG, "Can't execute predefined custom command: " + sessionCommand.customAction);
                    sendSessionResult(mediaSessionImpl, controllerInfo, i, new SessionResult(-6));
                    return;
                }
                SessionCommand sessionCommand2 = commandButtonConvertFromPredefinedCustomCommand.sessionCommand;
                if (sessionCommand2 != null) {
                    if7.o(sessionCommand2.commandCode == 40010);
                    dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_SESSION_SET_RATING, sendSessionResultWhenReady(new cw(commandButtonConvertFromPredefinedCustomCommand)));
                    return;
                }
                if (commandButtonConvertFromPredefinedCustomCommand.isPlayRequestPlayerAction(mediaSessionImpl.getPlayerWrapper())) {
                    playForControllerInfo(controllerInfo, i);
                } else {
                    int i2 = commandButtonConvertFromPredefinedCustomCommand.playerCommand;
                    if (i2 == 31) {
                        Object obj = commandButtonConvertFromPredefinedCustomCommand.parameter;
                        obj.getClass();
                        setMediaItemItemWithResetPositionForControllerInfo(controllerInfo, i, (MediaItem) obj, true);
                    } else {
                        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, i2, sendSessionResultSuccess(new cw(commandButtonConvertFromPredefinedCustomCommand)));
                    }
                }
                this.connectedControllersManager.flushCommandQueue(controllerInfo);
            } catch (RuntimeException e) {
                Log.w(TAG, "Failed to convert predefined custom command: " + sessionCommand.customAction, e);
                sendSessionResult(mediaSessionImpl, controllerInfo, i, new SessionResult(-3));
            }
        }
    }

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

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

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

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

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

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$getSearchResult$75(String str, int i, int i2, MediaLibraryService.LibraryParams libraryParams, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i3) {
        return mediaLibrarySessionImpl.onGetSearchResultOnHandler(controllerInfo, str, i, i2, 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 */ zb5 lambda$handleMediaItemsWhenReady$5(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, MediaItemPlayerTask mediaItemPlayerTask, List list) throws Exception {
        return Util.postOrRunWithCompletion(mediaSessionImpl.getApplicationHandler(), mediaSessionImpl.callWithControllerForCurrentRequestSet(controllerInfo, new d(mediaSessionImpl, mediaItemPlayerTask, controllerInfo, list, 10)), new SessionResult(0));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$handleMediaItemsWhenReady$6(SessionTask sessionTask, MediaItemPlayerTask mediaItemPlayerTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.isReleased() ? ks3.d(new SessionResult(-100)) : Util.transformFutureAsync((zb5) sessionTask.run(mediaSessionImpl, controllerInfo, i), new cr(mediaSessionImpl, controllerInfo, mediaItemPlayerTask, 1));
    }

    /* 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 */ zb5 lambda$handleMediaItemsWithStartPositionWhenReady$8(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask, MediaSession.MediaItemsWithStartPosition mediaItemsWithStartPosition) throws Exception {
        return Util.postOrRunWithCompletion(mediaSessionImpl.getApplicationHandler(), mediaSessionImpl.callWithControllerForCurrentRequestSet(controllerInfo, new bp(mediaSessionImpl, mediaItemsWithStartPositionPlayerTask, mediaItemsWithStartPosition, 5)), new SessionResult(0));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$handleMediaItemsWithStartPositionWhenReady$9(SessionTask sessionTask, MediaItemsWithStartPositionPlayerTask mediaItemsWithStartPositionPlayerTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.isReleased() ? ks3.d(new SessionResult(-100)) : Util.transformFutureAsync((zb5) sessionTask.run(mediaSessionImpl, controllerInfo, i), new cr(mediaSessionImpl, controllerInfo, mediaItemsWithStartPositionPlayerTask, 0));
    }

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

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$onCustomCommandWithProgressUpdate$24(boolean z, SessionCommand sessionCommand, Bundle bundle, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        Bundle bundle2;
        MediaSession.ControllerInfo controllerInfo2;
        SessionCommand sessionCommand2;
        MediaSessionImpl mediaSessionImpl2;
        ProgressReporter progressReporter;
        if (z) {
            sessionCommand2 = sessionCommand;
            mediaSessionImpl2 = mediaSessionImpl;
            bundle2 = bundle;
            controllerInfo2 = controllerInfo;
            progressReporter = new ProgressReporter(mediaSessionImpl2, controllerInfo2, i, sessionCommand2, bundle2);
        } else {
            bundle2 = bundle;
            controllerInfo2 = controllerInfo;
            sessionCommand2 = sessionCommand;
            mediaSessionImpl2 = mediaSessionImpl;
            progressReporter = null;
        }
        zb5<SessionResult> zb5VarOnCustomCommandOnHandler = mediaSessionImpl2.onCustomCommandOnHandler(controllerInfo2, progressReporter, sessionCommand2, bundle2);
        if (progressReporter != null) {
            progressReporter.setFuture(zb5VarOnCustomCommandOnHandler);
        }
        return zb5VarOnCustomCommandOnHandler;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$onSurfaceSizeChanged$57(int i, int i2, PlayerWrapper playerWrapper) {
        SurfaceHolderWithSize surfaceHolderWithSize;
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        mediaSessionImpl.getClass();
        if (mediaSessionImpl.shouldUseLegacySurfaceHandling() || (surfaceHolderWithSize = this.surfaceHolderWithSize) == null) {
            return;
        }
        surfaceHolderWithSize.setFixedSize(i, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* 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 */ zb5 lambda$queueSessionTaskWithPlayerCommandForControllerInfo$13(SessionTask sessionTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return (zb5) sessionTask.run(mediaSessionImpl, controllerInfo, i);
    }

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

    /* 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$45(int i, PlayerWrapper playerWrapper, MediaSession.ControllerInfo controllerInfo) {
        playerWrapper.removeMediaItem(maybeCorrectMediaItemIndex(controllerInfo, playerWrapper, i));
    }

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

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$replaceMediaItem$49(MediaItem mediaItem, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, bj4.r(mediaItem));
    }

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

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$replaceMediaItems$51(bj4 bj4Var, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onAddMediaItemsOnHandler(controllerInfo, bj4Var);
    }

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

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

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

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

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Multi-variable type inference failed */
    public static /* synthetic */ void lambda$sendLibraryResultWhenReady$10(MediaSession.ControllerInfo controllerInfo, int i, zb5 zb5Var) {
        LibraryResult libraryResultOfError;
        try {
            libraryResultOfError = (LibraryResult) zb5Var.get();
            if7.l(libraryResultOfError, "LibraryResult must not be null");
        } catch (InterruptedException e) {
            e = e;
            Log.w(TAG, "Library operation failed", e);
            libraryResultOfError = LibraryResult.ofError(-1);
        } catch (CancellationException e2) {
            Log.w(TAG, "Library operation cancelled", e2);
            libraryResultOfError = LibraryResult.ofError(1);
        } catch (ExecutionException e3) {
            e = e3;
            Log.w(TAG, "Library operation failed", e);
            libraryResultOfError = LibraryResult.ofError(-1);
        }
        sendLibraryResult(controllerInfo, i, libraryResultOfError);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$sendLibraryResultWhenReady$11(SessionTask sessionTask, MediaLibrarySessionImpl mediaLibrarySessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return handleSessionTaskWhenReady(mediaLibrarySessionImpl, controllerInfo, i, sessionTask, new bj(controllerInfo, i, 7));
    }

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

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:13:0x0023  */
    /* JADX WARN: Removed duplicated region for block: B:14:0x0025  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static /* synthetic */ void lambda$sendSessionResultWhenReady$2(MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i, zb5 zb5Var) {
        SessionResult sessionResult;
        try {
            sessionResult = (SessionResult) zb5Var.get();
            if7.l(sessionResult, "SessionResult must not be null");
        } catch (InterruptedException e) {
            e = e;
            Log.w(TAG, "Session operation failed", e);
            sessionResult = new SessionResult(!(e.getCause() instanceof UnsupportedOperationException) ? -6 : -1);
        } catch (CancellationException e2) {
            Log.w(TAG, "Session operation cancelled", e2);
            sessionResult = new SessionResult(1);
        } catch (ExecutionException e3) {
            e = e3;
            Log.w(TAG, "Session operation failed", e);
            sessionResult = new SessionResult(!(e.getCause() instanceof UnsupportedOperationException) ? -6 : -1);
        }
        sendSessionResult(mediaSessionImpl, controllerInfo, i, sessionResult);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$sendSessionResultWhenReady$3(SessionTask sessionTask, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return handleSessionTaskWhenReady(mediaSessionImpl, controllerInfo, i, sessionTask, new av(mediaSessionImpl, controllerInfo, i));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$setMediaItemItemWithResetPositionForControllerInfo$33(MediaItem mediaItem, boolean z, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, bj4.r(mediaItem), z ? -1 : mediaSessionImpl.getPlayerWrapper().getCurrentMediaItemIndex(), z ? C.TIME_UNSET : mediaSessionImpl.getPlayerWrapper().getCurrentPosition());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$setMediaItemWithStartPosition$32(MediaItem mediaItem, long j, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, bj4.r(mediaItem), 0, j);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ zb5 lambda$setMediaItemsWithResetPosition$34(List list, boolean z, MediaSessionImpl mediaSessionImpl, MediaSession.ControllerInfo controllerInfo, int i) {
        return mediaSessionImpl.onSetMediaItemsOnHandler(controllerInfo, list, z ? -1 : mediaSessionImpl.getPlayerWrapper().getCurrentMediaItemIndex(), z ? C.TIME_UNSET : mediaSessionImpl.getPlayerWrapper().getCurrentPosition());
    }

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

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

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

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setTrackSelectionParameters$70(TrackSelectionParameters trackSelectionParameters, PlayerWrapper playerWrapper) {
        playerWrapper.setTrackSelectionParameters(updateOverridesUsingUniqueTrackGroupIds(trackSelectionParameters));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$setVideoSurface$55(Surface surface, PlayerWrapper playerWrapper) {
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        mediaSessionImpl.getClass();
        if (mediaSessionImpl.shouldUseLegacySurfaceHandling()) {
            playerWrapper.setVideoSurface(surface);
            return;
        }
        if (surface == null) {
            playerWrapper.setVideoSurfaceHolder(null);
            this.surfaceHolderWithSize = null;
        } else {
            SurfaceHolderWithSize surfaceHolderWithSize = new SurfaceHolderWithSize(surface);
            this.surfaceHolderWithSize = surfaceHolderWithSize;
            playerWrapper.setVideoSurfaceHolder(surfaceHolderWithSize);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$setVideoSurfaceWithSize$56(Surface surface, int i, int i2, PlayerWrapper playerWrapper) {
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        mediaSessionImpl.getClass();
        if (mediaSessionImpl.shouldUseLegacySurfaceHandling()) {
            playerWrapper.setVideoSurface(surface);
            return;
        }
        if (surface == null) {
            playerWrapper.setVideoSurfaceHolder(null);
            this.surfaceHolderWithSize = null;
        } else {
            SurfaceHolderWithSize surfaceHolderWithSize = new SurfaceHolderWithSize(surface, i, i2);
            this.surfaceHolderWithSize = surfaceHolderWithSize;
            playerWrapper.setVideoSurfaceHolder(surfaceHolderWithSize);
        }
    }

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

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

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

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

    private <K extends MediaSessionImpl> void queueSessionTaskWithPlayerCommandForControllerInfo(final MediaSession.ControllerInfo controllerInfo, final int i, final int i2, final SessionTask<zb5<Void>, 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.cy
                    @Override // java.lang.Runnable
                    public final void run() {
                        this.a.lambda$queueSessionTaskWithPlayerCommandForControllerInfo$14(controllerInfo, i2, mediaSessionImpl, i, sessionTask);
                    }
                });
                Binder.restoreCallingIdentity(jClearCallingIdentity);
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

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

    private static <V, K extends MediaLibrarySessionImpl> SessionTask<zb5<Void>, K> sendLibraryResultWhenReady(SessionTask<zb5<LibraryResult<V>>, K> sessionTask) {
        return new cz(sessionTask, 0);
    }

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

    private static <K extends MediaSessionImpl> SessionTask<zb5<Void>, K> sendSessionResultSuccess(Consumer<PlayerWrapper> consumer) {
        return sendSessionResultSuccess(new bi(consumer, 8));
    }

    private static <K extends MediaSessionImpl> SessionTask<zb5<Void>, K> sendSessionResultWhenReady(SessionTask<zb5<SessionResult>, K> sessionTask) {
        return new cz(sessionTask, 1);
    }

    private void setMediaItemItemWithResetPositionForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i, MediaItem mediaItem, boolean z) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 31, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new bf(1, mediaItem, z), new t(5))));
    }

    /* JADX WARN: Multi-variable type inference failed */
    private TrackSelectionParameters updateOverridesUsingUniqueTrackGroupIds(TrackSelectionParameters trackSelectionParameters) {
        if (trackSelectionParameters.overrides.isEmpty()) {
            return trackSelectionParameters;
        }
        TrackSelectionParameters.Builder builderClearOverrides = trackSelectionParameters.buildUpon().clearOverrides();
        p7a it = trackSelectionParameters.overrides.values().iterator();
        while (it.hasNext()) {
            TrackSelectionOverride trackSelectionOverride = (TrackSelectionOverride) it.next();
            TrackGroup trackGroup = (TrackGroup) this.trackGroupIdMap.p().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(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new ct(MediaItem.fromBundle(bundle), 2), new t(17))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItemWithIndex(@rq6 IMediaController iMediaController, int i, int i2, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null || i2 < 0) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new ct(MediaItem.fromBundle(bundle), 0), new cq(this, i2, 1))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItems(@rq6 IMediaController iMediaController, int i, @rq6 IBinder iBinder) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new cu(1, BundleCollectionUtil.fromBundleList(new defpackage.av(25), BundleListRetriever.getList(iBinder))), new t(16))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void addMediaItemsWithIndex(@rq6 IMediaController iMediaController, int i, int i2, @rq6 IBinder iBinder) {
        if (iMediaController == null || iBinder == null || i2 < 0) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new cu(0, BundleCollectionUtil.fromBundleList(new defpackage.av(25), BundleListRetriever.getList(iBinder))), new cq(this, i2, 3))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

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

    public void connect(@rq6 IMediaController iMediaController, @rq6 MediaSession.ControllerInfo controllerInfo) {
        if (iMediaController == null || controllerInfo == null) {
            SessionUtil.disconnectIMediaController(iMediaController);
            return;
        }
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        if (mediaSessionImpl == null || mediaSessionImpl.isReleased()) {
            SessionUtil.disconnectIMediaController(iMediaController);
        } else {
            this.pendingControllers.add(controllerInfo);
            Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new d(this, controllerInfo, mediaSessionImpl, iMediaController, 9));
        }
    }

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

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

    @Override // androidx.media3.session.IMediaSession
    public void flushCommandQueue(@rq6 IMediaController iMediaController) {
        if (iMediaController == null) {
            return;
        }
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                MediaSession.ControllerInfo controller = this.connectedControllersManager.getController(iMediaController.asBinder());
                if (controller != null) {
                    Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new g(this, controller, 13));
                }
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public PlayerInfo generateAndCacheUniqueTrackGroupIds(PlayerInfo playerInfo) {
        bj4<Tracks.Group> groups = playerInfo.currentTracks.getGroups();
        bj4.a aVarI = bj4.i();
        si4.a aVar = new si4.a(4);
        for (int i = 0; i < groups.size(); i++) {
            Tracks.Group group = groups.get(i);
            TrackGroup mediaTrackGroup = group.getMediaTrackGroup();
            String strGenerateUniqueTrackGroupId = (String) this.trackGroupIdMap.get(mediaTrackGroup);
            if (strGenerateUniqueTrackGroupId == null) {
                strGenerateUniqueTrackGroupId = generateUniqueTrackGroupId(mediaTrackGroup);
            }
            aVar.g(mediaTrackGroup, strGenerateUniqueTrackGroupId);
            aVarI.h(group.copyWithId(strGenerateUniqueTrackGroupId));
        }
        this.trackGroupIdMap = aVar.f();
        PlayerInfo playerInfoCopyWithCurrentTracks = playerInfo.copyWithCurrentTracks(new Tracks(aVarI.j()));
        if (playerInfoCopyWithCurrentTracks.trackSelectionParameters.overrides.isEmpty()) {
            return playerInfoCopyWithCurrentTracks;
        }
        TrackSelectionParameters.Builder builderClearOverrides = playerInfoCopyWithCurrentTracks.trackSelectionParameters.buildUpon().clearOverrides();
        p7a 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(@rq6 IMediaController iMediaController, int i, @rq6 String str, int i2, int i3, @rq6 Bundle bundle) {
        MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getChildren(): Ignoring empty parentId");
            return;
        }
        if (i2 < 0) {
            Log.w(TAG, "getChildren(): Ignoring negative page");
            return;
        }
        if (i3 < 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 e) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_GET_CHILDREN, sendLibraryResultWhenReady(new cp(str, i2, i3, libraryParamsFromBundle, 0)));
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void getItem(@rq6 IMediaController iMediaController, int i, @rq6 String str) {
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getItem(): Ignoring empty mediaId");
        } else {
            dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_GET_ITEM, sendLibraryResultWhenReady(new co(str, 1)));
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void getLibraryRoot(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (bundle == null) {
            libraryParamsFromBundle = null;
        } else {
            try {
                libraryParamsFromBundle = MediaLibraryService.LibraryParams.fromBundle(bundle);
            } catch (RuntimeException e) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i, 50000, sendLibraryResultWhenReady(new bi(libraryParamsFromBundle, 7)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void getSearchResult(@rq6 IMediaController iMediaController, int i, @rq6 String str, int i2, int i3, @rq6 Bundle bundle) {
        MediaLibraryService.LibraryParams libraryParamsFromBundle;
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "getSearchResult(): Ignoring empty query");
            return;
        }
        if (i2 < 0) {
            Log.w(TAG, "getSearchResult(): Ignoring negative page");
            return;
        }
        if (i3 < 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 e) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_GET_SEARCH_RESULT, sendLibraryResultWhenReady(new cp(str, i2, i3, libraryParamsFromBundle, 1)));
    }

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

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

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

    @Override // androidx.media3.session.IMediaSession
    public void moveMediaItems(@rq6 IMediaController iMediaController, int i, final int i2, final int i3, final int i4) {
        if (iMediaController == null || i2 < 0 || i3 < i2 || i4 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultSuccess((Consumer<PlayerWrapper>) new Consumer() { // from class: androidx.media3.session.cv
            @Override // androidx.media3.common.util.Consumer
            public final void accept(Object obj) {
                ((PlayerWrapper) obj).moveMediaItems(i2, i3, i4);
            }
        }));
    }

    @Override // androidx.media3.session.IMediaSession
    public void mute(@rq6 IMediaController iMediaController, int i) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 24, sendSessionResultSuccess(new t(6)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void onControllerResult(@rq6 IMediaController iMediaController, int i, @rq6 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(i, sessionResultFromBundle);
            } finally {
                Binder.restoreCallingIdentity(jClearCallingIdentity);
            }
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for SessionResult", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void onCustomCommand(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle, @rq6 Bundle bundle2) {
        onCustomCommandWithProgressUpdate(iMediaController, i, bundle, bundle2, false);
    }

    @Override // androidx.media3.session.IMediaSession
    public void onCustomCommandWithProgressUpdate(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle, @rq6 Bundle bundle2, boolean z) {
        Bundle bundleConvertToNullIfInvalid = Util.convertToNullIfInvalid(bundle2);
        if (iMediaController == null || bundle == null || bundleConvertToNullIfInvalid == null) {
            return;
        }
        try {
            SessionCommand sessionCommandFromBundle = SessionCommand.fromBundle(bundle);
            if (CommandButton.isPredefinedCustomCommandButtonCode(sessionCommandFromBundle.customAction)) {
                dispatchCustomCommandAsPredefinedCommand(iMediaController, i, sessionCommandFromBundle);
            } else {
                dispatchSessionTaskWithSessionCommand(iMediaController, i, sessionCommandFromBundle, sendSessionResultWhenReady(new y(z, sessionCommandFromBundle, bundleConvertToNullIfInvalid)));
            }
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for SessionCommand", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void onSurfaceSizeChanged(@rq6 IMediaController iMediaController, int i, int i2, int i3) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 27, sendSessionResultSuccess((Consumer<PlayerWrapper>) new cn(this, i2, i3)));
    }

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

    public void pauseForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 1, sendSessionResultSuccess(new t(7)));
    }

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

    public void playForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 1, sendSessionResultSuccess(new j(this, controllerInfo, 18)));
    }

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

    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(@rq6 IMediaController iMediaController, int i, int i2) {
        if (iMediaController == null || i2 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultSuccess(new cq(this, i2, 4)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void removeMediaItems(@rq6 IMediaController iMediaController, int i, int i2, int i3) {
        if (iMediaController == null || i2 < 0 || i3 < i2) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultSuccess((ControllerPlayerTask) new cn(this, i2, i3)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void replaceMediaItem(@rq6 IMediaController iMediaController, int i, int i2, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null || i2 < 0) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new ct(MediaItem.fromBundle(bundle), 1), new cq(this, i2, 2))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void replaceMediaItems(@rq6 IMediaController iMediaController, int i, int i2, int i3, @rq6 IBinder iBinder) {
        if (iMediaController == null || iBinder == null || i2 < 0 || i3 < i2) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWhenReady(new bw(4, BundleCollectionUtil.fromBundleList(new defpackage.av(25), BundleListRetriever.getList(iBinder))), new cn(this, i2, i3))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void search(@rq6 IMediaController iMediaController, int i, @rq6 String str, @rq6 Bundle bundle) {
        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 e) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_SEARCH, sendLibraryResultWhenReady(new a0(str, 1, libraryParamsFromBundle)));
    }

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

    public void seekBackForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 11, sendSessionResultSuccess(new t(10)));
    }

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

    public void seekForwardForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 12, sendSessionResultSuccess(new t(13)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void seekTo(@rq6 IMediaController iMediaController, int i, long j) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 5, sendSessionResultSuccess(new cd(j, 2)));
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void seekToDefaultPositionWithMediaItemIndex(@rq6 IMediaController iMediaController, int i, int i2) {
        if (iMediaController == null || i2 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 10, sendSessionResultSuccess(new cq(this, i2, 0)));
    }

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

    public void seekToNextForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 9, sendSessionResultSuccess(new t(14)));
    }

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

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

    public void seekToPreviousForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 7, sendSessionResultSuccess(new t(11)));
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void seekToWithMediaItemIndex(@rq6 IMediaController iMediaController, int i, int i2, long j) {
        if (iMediaController == null || i2 < 0) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 10, sendSessionResultSuccess(new ax(i2, j, this)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setAudioAttributes(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle, boolean z) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 35, sendSessionResultSuccess(new bf(2, AudioAttributes.fromBundle(bundle), z)));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for AudioAttributes", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceMuted(@rq6 IMediaController iMediaController, int i, boolean z) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 26, sendSessionResultSuccess(new ap(z, 5)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setDeviceMutedWithFlags(@rq6 IMediaController iMediaController, int i, boolean z, int i2) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 34, sendSessionResultSuccess(new ce(z, i2, 2)));
    }

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

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

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

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemWithResetPosition(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle, boolean z) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            MediaItem mediaItemFromBundle = MediaItem.fromBundle(bundle);
            MediaSession.ControllerInfo controller = this.connectedControllersManager.getController(iMediaController.asBinder());
            if (controller != null) {
                setMediaItemItemWithResetPositionForControllerInfo(controller, i, mediaItemFromBundle, z);
            }
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemWithStartPosition(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle, long j) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 31, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new ae(MediaItem.fromBundle(bundle), j), new t(5))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemsWithResetPosition(@rq6 IMediaController iMediaController, int i, @rq6 IBinder iBinder, boolean z) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new bf(3, BundleCollectionUtil.fromBundleList(new defpackage.av(25), BundleListRetriever.getList(iBinder)), z), new t(5))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setMediaItemsWithStartIndex(@rq6 IMediaController iMediaController, int i, @rq6 IBinder iBinder, int i2, long j) {
        if (iMediaController == null || iBinder == null) {
            return;
        }
        if (i2 == -1 || i2 >= 0) {
            try {
                queueSessionTaskWithPlayerCommand(iMediaController, i, 20, sendSessionResultWhenReady(handleMediaItemsWithStartPositionWhenReady(new ax(i2, j, BundleCollectionUtil.fromBundleList(new defpackage.av(25), BundleListRetriever.getList(iBinder))), new t(5))));
            } catch (RuntimeException e) {
                Log.w(TAG, "Ignoring malformed Bundle for MediaItem", e);
            }
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlayWhenReady(@rq6 IMediaController iMediaController, int i, boolean z) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 1, sendSessionResultSuccess(new ap(z, 4)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setPlaybackParameters(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 13, sendSessionResultSuccess(new ad(3, PlaybackParameters.fromBundle(bundle))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for PlaybackParameters", e);
        }
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void setPlaylistMetadata(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 19, sendSessionResultSuccess(new ag(3, MediaMetadata.fromBundle(bundle))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for MediaMetadata", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setRating(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_SESSION_SET_RATING, sendSessionResultWhenReady(new bi(Rating.fromBundle(bundle), 6)));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for Rating", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setRatingWithMediaId(@rq6 IMediaController iMediaController, int i, @rq6 String str, @rq6 Bundle bundle) {
        if (iMediaController == null || str == null || bundle == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "setRatingWithMediaId(): Ignoring empty mediaId");
            return;
        }
        try {
            dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_SESSION_SET_RATING, sendSessionResultWhenReady(new j(str, Rating.fromBundle(bundle))));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for Rating", e);
        }
    }

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

    @Override // androidx.media3.session.IMediaSession
    public void setShuffleModeEnabled(@rq6 IMediaController iMediaController, int i, boolean z) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 14, sendSessionResultSuccess(new ap(z, 6)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setTrackSelectionParameters(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        if (iMediaController == null || bundle == null) {
            return;
        }
        try {
            queueSessionTaskWithPlayerCommand(iMediaController, i, 29, sendSessionResultSuccess(new j(this, TrackSelectionParameters.fromBundle(bundle), 17)));
        } catch (RuntimeException e) {
            Log.w(TAG, "Ignoring malformed Bundle for TrackSelectionParameters", e);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void setVideoSurface(@rq6 IMediaController iMediaController, int i, @rq6 Surface surface) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 27, sendSessionResultSuccess(new j(this, surface, 21)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void setVideoSurfaceWithSize(@rq6 IMediaController iMediaController, int i, @rq6 Surface surface, int i2, int i3) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 27, sendSessionResultSuccess(new af(i2, i3, 2, this, surface)));
    }

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

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

    public void stopForControllerInfo(MediaSession.ControllerInfo controllerInfo, int i) {
        queueSessionTaskWithPlayerCommandForControllerInfo(controllerInfo, i, 3, sendSessionResultSuccess(new t(19)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void subscribe(@rq6 IMediaController iMediaController, int i, @rq6 String str, @rq6 Bundle bundle) {
        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 e) {
                Log.w(TAG, "Ignoring malformed Bundle for LibraryParams", e);
                return;
            }
        }
        dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_SUBSCRIBE, sendLibraryResultWhenReady(new a0(str, 0, libraryParamsFromBundle)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void unmute(@rq6 IMediaController iMediaController, int i) {
        if (iMediaController == null) {
            return;
        }
        queueSessionTaskWithPlayerCommand(iMediaController, i, 24, sendSessionResultSuccess(new t(20)));
    }

    @Override // androidx.media3.session.IMediaSession
    public void unsubscribe(@rq6 IMediaController iMediaController, int i, @rq6 String str) {
        if (iMediaController == null) {
            return;
        }
        if (TextUtils.isEmpty(str)) {
            Log.w(TAG, "unsubscribe(): Ignoring empty parentId");
        } else {
            dispatchSessionTaskWithSessionCommand(iMediaController, i, SessionCommand.COMMAND_CODE_LIBRARY_UNSUBSCRIBE, sendLibraryResultWhenReady(new co(str, 0)));
        }
    }

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

    private static <K extends MediaSessionImpl> SessionTask<zb5<Void>, K> sendSessionResultSuccess(ControllerPlayerTask controllerPlayerTask) {
        return new bi(controllerPlayerTask, 9);
    }

    private <K extends MediaSessionImpl> void dispatchSessionTaskWithSessionCommand(IMediaController iMediaController, final int i, @rq6 final SessionCommand sessionCommand, final int i2, final SessionTask<zb5<Void>, 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) {
                    Binder.restoreCallingIdentity(jClearCallingIdentity);
                } else {
                    Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new Runnable() { // from class: androidx.media3.session.cx
                        @Override // java.lang.Runnable
                        public final void run() {
                            this.a.lambda$dispatchSessionTaskWithSessionCommand$15(controller, sessionCommand, mediaSessionImpl, i, i2, sessionTask);
                        }
                    });
                    Binder.restoreCallingIdentity(jClearCallingIdentity);
                }
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }

    @Override // androidx.media3.session.IMediaSession
    public void connect(@rq6 IMediaController iMediaController, int i, @rq6 Bundle bundle) {
        MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
        if (iMediaController != null && bundle != null && mediaSessionImpl != null) {
            try {
                ConnectionRequest connectionRequestFromBundle = ConnectionRequest.fromBundle(bundle);
                int callingUid = Binder.getCallingUid();
                int callingPid = Binder.getCallingPid();
                String str = connectionRequestFromBundle.packageName;
                int iCheckPackageValidity = SessionUtil.checkPackageValidity(mediaSessionImpl.getContext(), str, callingUid);
                if (iCheckPackageValidity == 1) {
                    Log.w(TAG, "Ignoring connection from invalid package name " + str + " (uid=" + callingUid + ")");
                    SessionUtil.disconnectIMediaController(iMediaController);
                    return;
                }
                long jClearCallingIdentity = Binder.clearCallingIdentity();
                if (callingPid == 0) {
                    callingPid = connectionRequestFromBundle.pid;
                }
                try {
                    MediaSessionManager.RemoteUserInfo remoteUserInfo = new MediaSessionManager.RemoteUserInfo(str, callingPid, callingUid);
                    boolean zIsTrustedForMediaControl = MediaSessionManager.getSessionManager(mediaSessionImpl.getContext()).isTrustedForMediaControl(remoteUserInfo);
                    int i2 = connectionRequestFromBundle.libraryVersion;
                    int i3 = connectionRequestFromBundle.controllerInterfaceVersion;
                    connect(iMediaController, new MediaSession.ControllerInfo(remoteUserInfo, i2, i3, zIsTrustedForMediaControl, new Controller2Cb(iMediaController, i3), connectionRequestFromBundle.connectionHints, connectionRequestFromBundle.maxCommandsForMediaItems, iCheckPackageValidity == 0));
                    return;
                } finally {
                    Binder.restoreCallingIdentity(jClearCallingIdentity);
                }
            } catch (RuntimeException e) {
                Log.w(TAG, "Ignoring malformed Bundle for ConnectionRequest", e);
                return;
            }
        }
        SessionUtil.disconnectIMediaController(iMediaController);
    }

    @Override // androidx.media3.session.IMediaSession
    public void release(@rq6 IMediaController iMediaController, int i) {
        if (iMediaController == null) {
            return;
        }
        long jClearCallingIdentity = Binder.clearCallingIdentity();
        try {
            MediaSessionImpl mediaSessionImpl = this.sessionImpl.get();
            if (mediaSessionImpl != null && !mediaSessionImpl.isReleased()) {
                Util.postOrRun(mediaSessionImpl.getApplicationHandler(), new g(this, iMediaController, 12));
            }
        } finally {
            Binder.restoreCallingIdentity(jClearCallingIdentity);
        }
    }
}