package androidx.media3.session;

import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.graphics.Rect;
import android.graphics.SurfaceTexture;
import android.media.session.MediaSession;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.os.RemoteException;
import android.os.SystemClock;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.TextureView;
import androidx.annotation.Nullable;
import androidx.collection.ArraySet;
import androidx.media3.common.AdPlaybackState;
import androidx.media3.common.AudioAttributes;
import androidx.media3.common.BundleListRetriever;
import androidx.media3.common.DeviceInfo;
import androidx.media3.common.FlagSet;
import androidx.media3.common.IllegalSeekPositionException;
import androidx.media3.common.MediaItem;
import androidx.media3.common.MediaMetadata;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.PlaybackParameters;
import androidx.media3.common.Player;
import androidx.media3.common.Rating;
import androidx.media3.common.Timeline;
import androidx.media3.common.TrackSelectionParameters;
import androidx.media3.common.Tracks;
import androidx.media3.common.VideoSize;
import androidx.media3.common.text.CueGroup;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.BundleCollectionUtil;
import androidx.media3.common.util.Clock;
import androidx.media3.common.util.Consumer;
import androidx.media3.common.util.ListenerSet;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.Size;
import androidx.media3.common.util.Util;
import androidx.media3.session.IMediaSession;
import androidx.media3.session.IMediaSessionService;
import androidx.media3.session.MediaController;
import androidx.media3.session.PlayerInfo;
import androidx.media3.session.SequencedFutureManager;
import androidx.media3.session.legacy.MediaBrowserCompat;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

/* JADX INFO: loaded from: classes.dex */
class MediaControllerImplBase implements MediaController.MediaControllerImpl {
    private static final long RELEASE_TIMEOUT_MS = 30000;
    public static final String TAG = "MCImplBase";

    @Nullable
    private SessionToken connectedToken;
    private final Bundle connectionHints;
    private final Context context;
    protected final MediaControllerStub controllerStub;
    private long currentPositionMs;
    private final IBinder.DeathRecipient deathRecipient;
    private final Handler fallbackPlaybackInfoUpdateHandler;
    private final FlushCommandQueueHandler flushCommandQueueHandler;

    @Nullable
    private IMediaSession iSession;
    private final MediaController instance;
    private Player.Commands intersectedPlayerCommands;
    private long lastSetPlayWhenReadyCalledTimeMs;
    private final ListenerSet<Player.Listener> listeners;
    private final ArraySet<Integer> pendingMaskingSequencedFutureNumbers;

    @Nullable
    private PlayerInfo pendingPlayerInfo;

    @Nullable
    private android.media.session.MediaController platformController;
    private Player.Commands playerCommandsFromPlayer;
    private boolean released;
    protected final SequencedFutureManager sequencedFutureManager;

    @Nullable
    private SessionServiceConnection serviceConnection;

    @Nullable
    private PendingIntent sessionActivity;
    private Bundle sessionExtras;
    private final SurfaceCallback surfaceCallback;
    private final SessionToken token;

    @Nullable
    private Surface videoSurface;

    @Nullable
    private SurfaceHolder videoSurfaceHolder;

    @Nullable
    private TextureView videoTextureView;
    private PlayerInfo playerInfo = PlayerInfo.DEFAULT;
    private Size surfaceSize = Size.UNKNOWN;
    private SessionCommands sessionCommands = SessionCommands.EMPTY;
    private ImmutableList<CommandButton> customLayoutOriginal = ImmutableList.of();
    private ImmutableList<CommandButton> mediaButtonPreferencesOriginal = ImmutableList.of();
    private ImmutableList<CommandButton> resolvedMediaButtonPreferences = ImmutableList.of();
    private ImmutableList<CommandButton> resolvedCustomLayout = ImmutableList.of();
    private ImmutableMap<String, CommandButton> commandButtonsForMediaItemsMap = ImmutableMap.of();
    private Player.Commands playerCommandsFromSession = Player.Commands.EMPTY;

    /* JADX INFO: Access modifiers changed from: private */
    class FlushCommandQueueHandler {
        private static final int MSG_FLUSH_COMMAND_QUEUE = 1;
        private final Handler handler;

        public FlushCommandQueueHandler(Looper looper) {
            this.handler = new Handler(looper, new Handler.Callback() { // from class: androidx.media3.session.f1
                @Override // android.os.Handler.Callback
                public final boolean handleMessage(Message message) {
                    return this.f2658a.handleMessage(message);
                }
            });
        }

        private void flushCommandQueue() {
            try {
                MediaControllerImplBase.this.iSession.flushCommandQueue(MediaControllerImplBase.this.controllerStub);
            } catch (RemoteException unused) {
                Log.w(MediaControllerImplBase.TAG, "Error in sending flushCommandQueue");
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public boolean handleMessage(Message message) {
            if (message.what == 1) {
                flushCommandQueue();
            }
            return true;
        }

        public void release() {
            if (this.handler.hasMessages(1)) {
                flushCommandQueue();
            }
            this.handler.removeCallbacksAndMessages(null);
        }

        public void sendFlushCommandQueueMessage() {
            if (MediaControllerImplBase.this.iSession == null || this.handler.hasMessages(1)) {
                return;
            }
            this.handler.sendEmptyMessage(1);
        }
    }

    private static final class PeriodInfo {
        private final int index;
        private final long periodPositionUs;

        public PeriodInfo(int i2, long j2) {
            this.index = i2;
            this.periodPositionUs = j2;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    interface RemoteSessionTask {
        void run(IMediaSession iMediaSession, int i2) throws RemoteException;
    }

    private class SessionServiceConnection implements ServiceConnection {
        private final Bundle connectionHints;

        public SessionServiceConnection(Bundle bundle) {
            this.connectionHints = bundle;
        }

        @Override // android.content.ServiceConnection
        public void onBindingDied(ComponentName componentName) {
            MediaController mediaControllerImplBase = MediaControllerImplBase.this.getInstance();
            MediaController mediaControllerImplBase2 = MediaControllerImplBase.this.getInstance();
            Objects.requireNonNull(mediaControllerImplBase2);
            mediaControllerImplBase.runOnApplicationLooper(new S(mediaControllerImplBase2));
        }

        @Override // android.content.ServiceConnection
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            try {
                if (MediaControllerImplBase.this.token.getPackageName().equals(componentName.getPackageName())) {
                    IMediaSessionService iMediaSessionServiceAsInterface = IMediaSessionService.Stub.asInterface(iBinder);
                    if (iMediaSessionServiceAsInterface == null) {
                        Log.e(MediaControllerImplBase.TAG, "Service interface is missing.");
                        return;
                    } else {
                        iMediaSessionServiceAsInterface.connect(MediaControllerImplBase.this.controllerStub, new ConnectionRequest(MediaControllerImplBase.this.getContext().getPackageName(), Process.myPid(), this.connectionHints, MediaControllerImplBase.this.instance.getMaxCommandsForMediaItems()).toBundle());
                        return;
                    }
                }
                Log.e(MediaControllerImplBase.TAG, "Expected connection to " + MediaControllerImplBase.this.token.getPackageName() + " but is connected to " + componentName);
            } catch (RemoteException unused) {
                Log.w(MediaControllerImplBase.TAG, "Service " + componentName + " has died prematurely");
            } finally {
                MediaController mediaControllerImplBase = MediaControllerImplBase.this.getInstance();
                MediaController mediaControllerImplBase2 = MediaControllerImplBase.this.getInstance();
                Objects.requireNonNull(mediaControllerImplBase2);
                mediaControllerImplBase.runOnApplicationLooper(new S(mediaControllerImplBase2));
            }
        }

        @Override // android.content.ServiceConnection
        public void onServiceDisconnected(ComponentName componentName) {
            MediaController mediaControllerImplBase = MediaControllerImplBase.this.getInstance();
            MediaController mediaControllerImplBase2 = MediaControllerImplBase.this.getInstance();
            Objects.requireNonNull(mediaControllerImplBase2);
            mediaControllerImplBase.runOnApplicationLooper(new S(mediaControllerImplBase2));
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    class SurfaceCallback implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener {
        private SurfaceCallback() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$onSurfaceTextureAvailable$2(IMediaSession iMediaSession, int i2) throws RemoteException {
            MediaControllerImplBase mediaControllerImplBase = MediaControllerImplBase.this;
            iMediaSession.setVideoSurface(mediaControllerImplBase.controllerStub, i2, mediaControllerImplBase.videoSurface);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$onSurfaceTextureDestroyed$3(IMediaSession iMediaSession, int i2) throws RemoteException {
            iMediaSession.setVideoSurface(MediaControllerImplBase.this.controllerStub, i2, null);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$surfaceCreated$0(IMediaSession iMediaSession, int i2) throws RemoteException {
            MediaControllerImplBase mediaControllerImplBase = MediaControllerImplBase.this;
            iMediaSession.setVideoSurface(mediaControllerImplBase.controllerStub, i2, mediaControllerImplBase.videoSurface);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$surfaceDestroyed$1(IMediaSession iMediaSession, int i2) throws RemoteException {
            iMediaSession.setVideoSurface(MediaControllerImplBase.this.controllerStub, i2, null);
        }

        @Override // android.view.TextureView.SurfaceTextureListener
        public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int i2, int i3) {
            if (MediaControllerImplBase.this.videoTextureView == null || MediaControllerImplBase.this.videoTextureView.getSurfaceTexture() != surfaceTexture) {
                return;
            }
            MediaControllerImplBase.this.videoSurface = new Surface(surfaceTexture);
            MediaControllerImplBase.this.dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.i1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i4) throws RemoteException {
                    this.f2693a.lambda$onSurfaceTextureAvailable$2(iMediaSession, i4);
                }
            });
            MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(i2, i3);
        }

        @Override // android.view.TextureView.SurfaceTextureListener
        public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
            if (MediaControllerImplBase.this.videoTextureView != null && MediaControllerImplBase.this.videoTextureView.getSurfaceTexture() == surfaceTexture) {
                MediaControllerImplBase.this.videoSurface = null;
                MediaControllerImplBase.this.dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.j1
                    @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                    public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                        this.f2701a.lambda$onSurfaceTextureDestroyed$3(iMediaSession, i2);
                    }
                });
                MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(0, 0);
            }
            return true;
        }

        @Override // android.view.TextureView.SurfaceTextureListener
        public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int i2, int i3) {
            if (MediaControllerImplBase.this.videoTextureView == null || MediaControllerImplBase.this.videoTextureView.getSurfaceTexture() != surfaceTexture) {
                return;
            }
            MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(i2, i3);
        }

        @Override // android.view.TextureView.SurfaceTextureListener
        public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
        }

        @Override // android.view.SurfaceHolder.Callback
        public void surfaceChanged(SurfaceHolder surfaceHolder, int i2, int i3, int i4) {
            if (MediaControllerImplBase.this.videoSurfaceHolder != surfaceHolder) {
                return;
            }
            MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(i3, i4);
        }

        @Override // android.view.SurfaceHolder.Callback
        public void surfaceCreated(SurfaceHolder surfaceHolder) {
            if (MediaControllerImplBase.this.videoSurfaceHolder != surfaceHolder) {
                return;
            }
            MediaControllerImplBase.this.videoSurface = surfaceHolder.getSurface();
            MediaControllerImplBase.this.dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.g1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2672a.lambda$surfaceCreated$0(iMediaSession, i2);
                }
            });
            Rect surfaceFrame = surfaceHolder.getSurfaceFrame();
            MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(surfaceFrame.width(), surfaceFrame.height());
        }

        @Override // android.view.SurfaceHolder.Callback
        public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
            if (MediaControllerImplBase.this.videoSurfaceHolder != surfaceHolder) {
                return;
            }
            MediaControllerImplBase.this.videoSurface = null;
            MediaControllerImplBase.this.dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.h1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2682a.lambda$surfaceDestroyed$1(iMediaSession, i2);
                }
            });
            MediaControllerImplBase.this.maybeNotifySurfaceSizeChanged(0, 0);
        }
    }

    /* JADX WARN: Multi-variable type inference failed */
    public MediaControllerImplBase(Context context, MediaController mediaController, SessionToken sessionToken, Bundle bundle, Looper looper) {
        Player.Commands commands = Player.Commands.EMPTY;
        this.playerCommandsFromPlayer = commands;
        this.intersectedPlayerCommands = createIntersectedCommandsEnsuringCommandReleaseAvailable(this.playerCommandsFromSession, commands);
        this.listeners = new ListenerSet<>(looper, Clock.DEFAULT, new ListenerSet.IterationFinishedEvent() { // from class: androidx.media3.session.n0
        });
        this.fallbackPlaybackInfoUpdateHandler = new Handler(looper);
        this.instance = mediaController;
        Assertions.checkNotNull(context, "context must not be null");
        Assertions.checkNotNull(sessionToken, "token must not be null");
        this.context = context;
        this.sequencedFutureManager = new SequencedFutureManager();
        this.controllerStub = new MediaControllerStub(this);
        this.pendingMaskingSequencedFutureNumbers = new ArraySet<>();
        this.token = sessionToken;
        this.connectionHints = bundle;
        this.deathRecipient = new IBinder.DeathRecipient() { // from class: androidx.media3.session.p0
            @Override // android.os.IBinder.DeathRecipient
            public final void binderDied() {
                this.f2804e.lambda$new$1();
            }
        };
        this.surfaceCallback = new SurfaceCallback();
        this.sessionExtras = Bundle.EMPTY;
        this.serviceConnection = sessionToken.getType() != 0 ? new SessionServiceConnection(bundle) : null;
        this.flushCommandQueueHandler = new FlushCommandQueueHandler(looper);
        this.currentPositionMs = -9223372036854775807L;
        this.lastSetPlayWhenReadyCalledTimeMs = -9223372036854775807L;
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    private void addMediaItemsInternal(int i2, List<MediaItem> list) throws IllegalSeekPositionException {
        if (list.isEmpty()) {
            return;
        }
        if (this.playerInfo.timeline.isEmpty()) {
            setMediaItemsInternal(list, -1, -9223372036854775807L, false);
        } else {
            updatePlayerInfo(maskPlayerInfoForAddedItems(this.playerInfo, Math.min(i2, this.playerInfo.timeline.getWindowCount()), list, getCurrentPosition(), getContentPosition()), 0, null, null, this.playerInfo.timeline.isEmpty() ? 3 : null);
        }
    }

    private void clearSurfacesAndCallbacks() {
        TextureView textureView = this.videoTextureView;
        if (textureView != null) {
            textureView.setSurfaceTextureListener(null);
            this.videoTextureView = null;
        }
        SurfaceHolder surfaceHolder = this.videoSurfaceHolder;
        if (surfaceHolder != null) {
            surfaceHolder.removeCallback(this.surfaceCallback);
            this.videoSurfaceHolder = null;
        }
        if (this.videoSurface != null) {
            this.videoSurface = null;
        }
    }

    private static int convertRepeatModeForNavigation(int i2) {
        if (i2 == 1) {
            return 0;
        }
        return i2;
    }

    private static Player.Commands createIntersectedCommandsEnsuringCommandReleaseAvailable(Player.Commands commands, Player.Commands commands2) {
        Player.Commands commandsIntersect = MediaUtils.intersect(commands, commands2);
        return commandsIntersect.contains(32) ? commandsIntersect : commandsIntersect.buildUpon().add(32).build();
    }

    private static Timeline createMaskingTimeline(List<Timeline.Window> list, List<Timeline.Period> list2) {
        return new Timeline.RemotableTimeline(new ImmutableList.Builder().addAll(list).build(), new ImmutableList.Builder().addAll(list2).build(), MediaUtils.generateUnshuffledIndices(list.size()));
    }

    private static Timeline.Period createNewPeriod(int i2) {
        return new Timeline.Period().set((Object) null, (Object) null, i2, -9223372036854775807L, 0L, AdPlaybackState.NONE, true);
    }

    private static Timeline.Window createNewWindow(MediaItem mediaItem) {
        return new Timeline.Window().set(0, mediaItem, (Object) null, 0L, 0L, 0L, true, false, (MediaItem.LiveConfiguration) null, 0L, -9223372036854775807L, -1, -1, 0L);
    }

    /* JADX WARN: Type inference failed for: r0v1, types: [androidx.media3.session.SequencedFutureManager$SequencedFuture, com.google.common.util.concurrent.ListenableFuture] */
    private ListenableFuture dispatchRemoteSessionTask(@Nullable IMediaSession iMediaSession, RemoteSessionTask remoteSessionTask, boolean z2) {
        if (iMediaSession == null) {
            return Futures.immediateFuture(new SessionResult(-4));
        }
        ?? CreateSequencedFuture = this.sequencedFutureManager.createSequencedFuture(new SessionResult(1));
        int sequenceNumber = CreateSequencedFuture.getSequenceNumber();
        if (z2) {
            if (this.pendingMaskingSequencedFutureNumbers.isEmpty()) {
                this.pendingPlayerInfo = this.playerInfo;
            }
            this.pendingMaskingSequencedFutureNumbers.add(Integer.valueOf(sequenceNumber));
        }
        try {
            remoteSessionTask.run(iMediaSession, sequenceNumber);
        } catch (RemoteException e2) {
            Log.w(TAG, "Cannot connect to the service or the session is gone", e2);
            this.pendingMaskingSequencedFutureNumbers.remove(Integer.valueOf(sequenceNumber));
            this.sequencedFutureManager.setFutureResult(sequenceNumber, new SessionResult(-100));
        }
        return CreateSequencedFuture;
    }

    private void dispatchRemoteSessionTaskWithPlayerCommand(RemoteSessionTask remoteSessionTask) {
        this.flushCommandQueueHandler.sendFlushCommandQueueMessage();
        dispatchRemoteSessionTask(this.iSession, remoteSessionTask, true);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Multi-variable type inference failed */
    public void dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(RemoteSessionTask remoteSessionTask) {
        this.flushCommandQueueHandler.sendFlushCommandQueueMessage();
        ListenableFuture listenableFutureDispatchRemoteSessionTask = dispatchRemoteSessionTask(this.iSession, remoteSessionTask, true);
        try {
            LegacyConversions.getFutureResult(listenableFutureDispatchRemoteSessionTask, 3000L);
        } catch (ExecutionException e2) {
            throw new IllegalStateException(e2);
        } catch (TimeoutException e3) {
            if (listenableFutureDispatchRemoteSessionTask instanceof SequencedFutureManager.SequencedFuture) {
                int sequenceNumber = ((SequencedFutureManager.SequencedFuture) listenableFutureDispatchRemoteSessionTask).getSequenceNumber();
                this.pendingMaskingSequencedFutureNumbers.remove(Integer.valueOf(sequenceNumber));
                this.sequencedFutureManager.setFutureResult(sequenceNumber, new SessionResult(-1));
            }
            Log.w(TAG, "Synchronous command takes too long on the session side.", e3);
        }
    }

    private ListenableFuture dispatchRemoteSessionTaskWithSessionCommand(int i2, RemoteSessionTask remoteSessionTask) {
        return dispatchRemoteSessionTaskWithSessionCommandInternal(i2, null, remoteSessionTask);
    }

    private ListenableFuture dispatchRemoteSessionTaskWithSessionCommandInternal(int i2, @Nullable SessionCommand sessionCommand, RemoteSessionTask remoteSessionTask) {
        return dispatchRemoteSessionTask(sessionCommand != null ? getSessionInterfaceWithSessionCommandIfAble(sessionCommand) : getSessionInterfaceWithSessionCommandIfAble(i2), remoteSessionTask, false);
    }

    private static int getCurrentMediaItemIndexInternal(PlayerInfo playerInfo) {
        if (playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex == -1) {
            return 0;
        }
        return playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex;
    }

    private static int getNewPeriodIndexWithoutRemovedPeriods(Timeline timeline, int i2, int i3, int i4) {
        if (i2 == -1) {
            return i2;
        }
        while (i3 < i4) {
            Timeline.Window window = new Timeline.Window();
            timeline.getWindow(i3, window);
            i2 -= (window.lastPeriodIndex - window.firstPeriodIndex) + 1;
            i3++;
        }
        return i2;
    }

    @Nullable
    private PeriodInfo getPeriodInfo(Timeline timeline, int i2, long j2) {
        if (timeline.isEmpty()) {
            return null;
        }
        Timeline.Window window = new Timeline.Window();
        Timeline.Period period = new Timeline.Period();
        if (i2 == -1 || i2 >= timeline.getWindowCount()) {
            i2 = timeline.getFirstWindowIndex(getShuffleModeEnabled());
            j2 = timeline.getWindow(i2, window).getDefaultPositionMs();
        }
        return getPeriodInfo(timeline, window, period, i2, Util.msToUs(j2));
    }

    private static Timeline.Period getPeriodWithNewWindowIndex(Timeline timeline, int i2, int i3) {
        Timeline.Period period = new Timeline.Period();
        timeline.getPeriod(i2, period);
        period.windowIndex = i3;
        return period;
    }

    private boolean isPlayerCommandAvailable(int i2) {
        if (this.intersectedPlayerCommands.contains(i2)) {
            return true;
        }
        Log.w(TAG, "Controller isn't allowed to call command= " + i2);
        return false;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItem$30(MediaItem mediaItem, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.addMediaItem(this.controllerStub, i2, mediaItem.toBundleIncludeLocalConfiguration());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItem$31(int i2, MediaItem mediaItem, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.addMediaItemWithIndex(this.controllerStub, i3, i2, mediaItem.toBundleIncludeLocalConfiguration());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItems$32(List list, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.addMediaItems(this.controllerStub, i2, new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f())));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$addMediaItems$33(int i2, List list, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.addMediaItemsWithIndex(this.controllerStub, i3, i2, new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f())));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$clearMediaItems$36(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.clearMediaItems(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$clearVideoSurface$69(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$decreaseDeviceVolume$59(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.decreaseDeviceVolume(this.controllerStub, i2);
    }

    private /* synthetic */ void lambda$decreaseDeviceVolume$60(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$decreaseDeviceVolume$61(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.decreaseDeviceVolumeWithFlags(this.controllerStub, i3, i2);
    }

    private /* synthetic */ void lambda$decreaseDeviceVolume$62(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$increaseDeviceVolume$55(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.increaseDeviceVolume(this.controllerStub, i2);
    }

    private /* synthetic */ void lambda$increaseDeviceVolume$56(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$increaseDeviceVolume$57(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.increaseDeviceVolumeWithFlags(this.controllerStub, i3, i2);
    }

    private /* synthetic */ void lambda$increaseDeviceVolume$58(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$moveMediaItem$37(int i2, int i3, IMediaSession iMediaSession, int i4) throws RemoteException {
        iMediaSession.moveMediaItem(this.controllerStub, i4, i2, i3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$moveMediaItems$38(int i2, int i3, int i4, IMediaSession iMediaSession, int i5) throws RemoteException {
        iMediaSession.moveMediaItems(this.controllerStub, i5, i2, i3, i4);
    }

    private /* synthetic */ void lambda$new$0(Player.Listener listener, FlagSet flagSet) {
        listener.onEvents(getInstance(), new Player.Events(flagSet));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$new$1() {
        MediaController mediaControllerImplBase = getInstance();
        MediaController mediaControllerImplBase2 = getInstance();
        Objects.requireNonNull(mediaControllerImplBase2);
        mediaControllerImplBase.runOnApplicationLooper(new S(mediaControllerImplBase2));
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromPlayer$113(Player.Listener listener) {
        listener.onAvailableCommandsChanged(this.intersectedPlayerCommands);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromPlayer$114(MediaController.Listener listener) {
        listener.onCustomLayoutChanged(getInstance(), this.resolvedCustomLayout);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromPlayer$115(MediaController.Listener listener) {
        listener.onMediaButtonPreferencesChanged(getInstance(), this.resolvedMediaButtonPreferences);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromSession$109(Player.Listener listener) {
        listener.onAvailableCommandsChanged(this.intersectedPlayerCommands);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromSession$110(SessionCommands sessionCommands, MediaController.Listener listener) {
        listener.onAvailableSessionCommandsChanged(getInstance(), sessionCommands);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromSession$111(MediaController.Listener listener) {
        listener.onCustomLayoutChanged(getInstance(), this.resolvedCustomLayout);
    }

    private /* synthetic */ void lambda$onAvailableCommandsChangedFromSession$112(MediaController.Listener listener) {
        listener.onMediaButtonPreferencesChanged(getInstance(), this.resolvedMediaButtonPreferences);
    }

    private /* synthetic */ void lambda$onCustomCommand$108(SessionCommand sessionCommand, Bundle bundle, int i2, MediaController.Listener listener) {
        sendControllerResultWhenReady(i2, (ListenableFuture) Assertions.checkNotNull(listener.onCustomCommand(getInstance(), sessionCommand, bundle), "ControllerCallback#onCustomCommand() must not return null"));
    }

    private /* synthetic */ void lambda$onError$120(SessionError sessionError, MediaController.Listener listener) {
        listener.onError(getInstance(), sessionError);
    }

    private /* synthetic */ void lambda$onExtrasChanged$118(Bundle bundle, boolean z2, boolean z3, MediaController.Listener listener) {
        listener.onExtrasChanged(getInstance(), bundle);
        if (z2) {
            listener.onCustomLayoutChanged(getInstance(), this.resolvedCustomLayout);
        }
        if (z3) {
            listener.onMediaButtonPreferencesChanged(getInstance(), this.resolvedMediaButtonPreferences);
        }
    }

    private /* synthetic */ void lambda$onSetCustomLayout$116(boolean z2, boolean z3, int i2, MediaController.Listener listener) {
        ListenableFuture listenableFuture = (ListenableFuture) Assertions.checkNotNull(listener.onSetCustomLayout(getInstance(), this.resolvedCustomLayout), "MediaController.Listener#onSetCustomLayout() must not return null");
        if (z2) {
            listener.onCustomLayoutChanged(getInstance(), this.resolvedCustomLayout);
        }
        if (z3) {
            listener.onMediaButtonPreferencesChanged(getInstance(), this.resolvedMediaButtonPreferences);
        }
        sendControllerResultWhenReady(i2, listenableFuture);
    }

    private /* synthetic */ void lambda$onSetMediaButtonPreferences$117(boolean z2, boolean z3, int i2, MediaController.Listener listener) {
        ListenableFuture listenableFuture = (ListenableFuture) Assertions.checkNotNull(listener.onSetCustomLayout(getInstance(), this.resolvedCustomLayout), "MediaController.Listener#onSetCustomLayout() must not return null");
        if (z2) {
            listener.onCustomLayoutChanged(getInstance(), this.resolvedCustomLayout);
        }
        if (z3) {
            listener.onMediaButtonPreferencesChanged(getInstance(), this.resolvedMediaButtonPreferences);
        }
        sendControllerResultWhenReady(i2, listenableFuture);
    }

    private /* synthetic */ void lambda$onSetSessionActivity$119(PendingIntent pendingIntent, MediaController.Listener listener) {
        listener.onSessionActivityChanged(getInstance(), pendingIntent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$pause$6(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.pause(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$play$5(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.play(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$prepare$7(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.prepare(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$release$4() {
        SessionServiceConnection sessionServiceConnection = this.serviceConnection;
        if (sessionServiceConnection != null) {
            this.context.unbindService(sessionServiceConnection);
            this.serviceConnection = null;
        }
        this.controllerStub.destroy();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$removeMediaItem$34(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.removeMediaItem(this.controllerStub, i3, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$removeMediaItems$35(int i2, int i3, IMediaSession iMediaSession, int i4) throws RemoteException {
        iMediaSession.removeMediaItems(this.controllerStub, i4, i2, i3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$replaceMediaItem$39(int i2, MediaItem mediaItem, IMediaSession iMediaSession, int i3) throws RemoteException {
        if (((SessionToken) Assertions.checkNotNull(this.connectedToken)).getInterfaceVersion() >= 2) {
            iMediaSession.replaceMediaItem(this.controllerStub, i3, i2, mediaItem.toBundleIncludeLocalConfiguration());
        } else {
            iMediaSession.addMediaItemWithIndex(this.controllerStub, i3, i2 + 1, mediaItem.toBundleIncludeLocalConfiguration());
            iMediaSession.removeMediaItem(this.controllerStub, i3, i2);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$replaceMediaItems$40(List list, int i2, int i3, IMediaSession iMediaSession, int i4) throws RemoteException {
        BundleListRetriever bundleListRetriever = new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f()));
        if (((SessionToken) Assertions.checkNotNull(this.connectedToken)).getInterfaceVersion() >= 2) {
            iMediaSession.replaceMediaItems(this.controllerStub, i4, i2, i3, bundleListRetriever);
        } else {
            iMediaSession.addMediaItemsWithIndex(this.controllerStub, i4, i3, bundleListRetriever);
            iMediaSession.removeMediaItems(this.controllerStub, i4, i2, i3);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekBack$12(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekBack(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekForward$13(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekForward(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekTo$10(long j2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekTo(this.controllerStub, i2, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekTo$11(int i2, long j2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.seekToWithMediaItemIndex(this.controllerStub, i3, i2, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToDefaultPosition$8(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekToDefaultPosition(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToDefaultPosition$9(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.seekToDefaultPositionWithMediaItemIndex(this.controllerStub, i3, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToNext$44(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekToNext(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToNextMediaItem$42(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekToNextMediaItem(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToPrevious$43(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekToPrevious(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$seekToPreviousMediaItem$41(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.seekToPreviousMediaItem(this.controllerStub, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$sendControllerResultWhenReady$107(ListenableFuture listenableFuture, int i2) {
        SessionResult sessionResult;
        try {
            sessionResult = (SessionResult) Assertions.checkNotNull((SessionResult) listenableFuture.get(), "SessionResult must not be null");
        } catch (InterruptedException e2) {
            e = e2;
            Log.w(TAG, "Session operation failed", e);
            sessionResult = new SessionResult(-1);
        } catch (CancellationException e3) {
            Log.w(TAG, "Session operation cancelled", e3);
            sessionResult = new SessionResult(1);
        } catch (ExecutionException e4) {
            e = e4;
            Log.w(TAG, "Session operation failed", e);
            sessionResult = new SessionResult(-1);
        }
        sendControllerResult(i2, sessionResult);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$sendCustomCommand$21(SessionCommand sessionCommand, Bundle bundle, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.onCustomCommand(this.controllerStub, i2, sessionCommand.toBundle(), bundle);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setAudioAttributes$67(AudioAttributes audioAttributes, boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setAudioAttributes(this.controllerStub, i2, audioAttributes.toBundle(), z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setDeviceMuted$63(boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setDeviceMuted(this.controllerStub, i2, z2);
    }

    private /* synthetic */ void lambda$setDeviceMuted$64(boolean z2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(this.playerInfo.deviceVolume, z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setDeviceMuted$65(boolean z2, int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.setDeviceMutedWithFlags(this.controllerStub, i3, z2, i2);
    }

    private /* synthetic */ void lambda$setDeviceMuted$66(boolean z2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(this.playerInfo.deviceVolume, z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setDeviceVolume$51(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.setDeviceVolume(this.controllerStub, i3, i2);
    }

    private /* synthetic */ void lambda$setDeviceVolume$52(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setDeviceVolume$53(int i2, int i3, IMediaSession iMediaSession, int i4) throws RemoteException {
        iMediaSession.setDeviceVolumeWithFlags(this.controllerStub, i4, i2, i3);
    }

    private /* synthetic */ void lambda$setDeviceVolume$54(int i2, Player.Listener listener) {
        listener.onDeviceVolumeChanged(i2, this.playerInfo.deviceMuted);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setFutureResult$105() {
        PlayerInfo playerInfo = this.pendingPlayerInfo;
        if (playerInfo != null) {
            onPlayerInfoChanged(playerInfo, PlayerInfo.BundlingExclusions.NONE);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setFutureResult$106(int i2) {
        this.pendingMaskingSequencedFutureNumbers.remove(Integer.valueOf(i2));
        SessionToken sessionToken = this.connectedToken;
        if (sessionToken == null || sessionToken.getInterfaceVersion() >= 5 || !this.pendingMaskingSequencedFutureNumbers.isEmpty()) {
            return;
        }
        this.fallbackPlaybackInfoUpdateHandler.postDelayed(new Runnable() { // from class: androidx.media3.session.l0
            @Override // java.lang.Runnable
            public final void run() {
                this.f2729b.lambda$setFutureResult$105();
            }
        }, 500L);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItem$22(MediaItem mediaItem, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setMediaItem(this.controllerStub, i2, mediaItem.toBundleIncludeLocalConfiguration());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItem$23(MediaItem mediaItem, long j2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setMediaItemWithStartPosition(this.controllerStub, i2, mediaItem.toBundleIncludeLocalConfiguration(), j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItem$24(MediaItem mediaItem, boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setMediaItemWithResetPosition(this.controllerStub, i2, mediaItem.toBundleIncludeLocalConfiguration(), z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItems$25(List list, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setMediaItems(this.controllerStub, i2, new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f())));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItems$26(List list, boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setMediaItemsWithResetPosition(this.controllerStub, i2, new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f())), z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setMediaItems$27(List list, int i2, long j2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.setMediaItemsWithStartIndex(this.controllerStub, i3, new BundleListRetriever(BundleCollectionUtil.toBundleList(list, new C0254f())), i2, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setPlayWhenReady$14(boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setPlayWhenReady(this.controllerStub, i2, z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setPlaybackParameters$15(PlaybackParameters playbackParameters, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setPlaybackParameters(this.controllerStub, i2, playbackParameters.toBundle());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setPlaybackSpeed$17(float f2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setPlaybackSpeed(this.controllerStub, i2, f2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setPlaylistMetadata$28(MediaMetadata mediaMetadata, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setPlaylistMetadata(this.controllerStub, i2, mediaMetadata.toBundle());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setRating$19(String str, Rating rating, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setRatingWithMediaId(this.controllerStub, i2, str, rating.toBundle());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setRating$20(Rating rating, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setRating(this.controllerStub, i2, rating.toBundle());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setRepeatMode$45(int i2, IMediaSession iMediaSession, int i3) throws RemoteException {
        iMediaSession.setRepeatMode(this.controllerStub, i3, i2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setShuffleModeEnabled$47(boolean z2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setShuffleModeEnabled(this.controllerStub, i2, z2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setTrackSelectionParameters$75(TrackSelectionParameters trackSelectionParameters, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setTrackSelectionParameters(this.controllerStub, i2, trackSelectionParameters.toBundle());
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVideoSurface$70(Surface surface, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, surface);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVideoSurfaceHolder$71(Surface surface, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, surface);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVideoSurfaceHolder$72(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVideoTextureView$73(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, null);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVideoTextureView$74(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVideoSurface(this.controllerStub, i2, this.videoSurface);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$setVolume$49(float f2, IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.setVolume(this.controllerStub, i2, f2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$stop$2(IMediaSession iMediaSession, int i2) throws RemoteException {
        iMediaSession.stop(this.controllerStub, i2);
    }

    private static PlayerInfo maskPlayerInfoForAddedItems(PlayerInfo playerInfo, int i2, List<MediaItem> list, long j2, long j3) {
        int size;
        Timeline timeline = playerInfo.timeline;
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        int size2 = 0;
        for (int i3 = 0; i3 < timeline.getWindowCount(); i3++) {
            arrayList.add(timeline.getWindow(i3, new Timeline.Window()));
        }
        for (int i4 = 0; i4 < list.size(); i4++) {
            arrayList.add(i4 + i2, createNewWindow(list.get(i4)));
        }
        rebuildPeriods(timeline, arrayList, arrayList2);
        Timeline timelineCreateMaskingTimeline = createMaskingTimeline(arrayList, arrayList2);
        if (playerInfo.timeline.isEmpty()) {
            size = 0;
        } else {
            size = playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex >= i2 ? playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex + list.size() : playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex;
            size2 = playerInfo.sessionPositionInfo.positionInfo.periodIndex >= i2 ? playerInfo.sessionPositionInfo.positionInfo.periodIndex + list.size() : playerInfo.sessionPositionInfo.positionInfo.periodIndex;
        }
        return maskTimelineAndPositionInfo(playerInfo, timelineCreateMaskingTimeline, size, size2, j2, j3, 5);
    }

    private static PlayerInfo maskPlayerInfoForRemovedItems(PlayerInfo playerInfo, int i2, int i3, boolean z2, long j2, long j3) {
        int newPeriodIndexWithoutRemovedPeriods;
        int i4;
        int i5;
        PlayerInfo playerInfoMaskTimelineAndPositionInfo;
        Timeline timeline = playerInfo.timeline;
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (int i6 = 0; i6 < timeline.getWindowCount(); i6++) {
            if (i6 < i2 || i6 >= i3) {
                arrayList.add(timeline.getWindow(i6, new Timeline.Window()));
            }
        }
        rebuildPeriods(timeline, arrayList, arrayList2);
        Timeline timelineCreateMaskingTimeline = createMaskingTimeline(arrayList, arrayList2);
        int currentMediaItemIndexInternal = getCurrentMediaItemIndexInternal(playerInfo);
        int i7 = playerInfo.sessionPositionInfo.positionInfo.periodIndex;
        Timeline.Window window = new Timeline.Window();
        boolean z3 = currentMediaItemIndexInternal >= i2 && currentMediaItemIndexInternal < i3;
        if (timelineCreateMaskingTimeline.isEmpty()) {
            newPeriodIndexWithoutRemovedPeriods = 0;
            i4 = -1;
        } else if (z3) {
            int iResolveSubsequentMediaItemIndex = resolveSubsequentMediaItemIndex(playerInfo.repeatMode, playerInfo.shuffleModeEnabled, currentMediaItemIndexInternal, timeline, i2, i3);
            if (iResolveSubsequentMediaItemIndex == -1) {
                iResolveSubsequentMediaItemIndex = timelineCreateMaskingTimeline.getFirstWindowIndex(playerInfo.shuffleModeEnabled);
            } else if (iResolveSubsequentMediaItemIndex >= i3) {
                iResolveSubsequentMediaItemIndex -= i3 - i2;
            }
            newPeriodIndexWithoutRemovedPeriods = timelineCreateMaskingTimeline.getWindow(iResolveSubsequentMediaItemIndex, window).firstPeriodIndex;
            i4 = iResolveSubsequentMediaItemIndex;
        } else if (currentMediaItemIndexInternal >= i3) {
            i4 = currentMediaItemIndexInternal - (i3 - i2);
            newPeriodIndexWithoutRemovedPeriods = getNewPeriodIndexWithoutRemovedPeriods(timeline, i7, i2, i3);
        } else {
            newPeriodIndexWithoutRemovedPeriods = i7;
            i4 = currentMediaItemIndexInternal;
        }
        if (!z3) {
            i5 = 4;
            playerInfoMaskTimelineAndPositionInfo = maskTimelineAndPositionInfo(playerInfo, timelineCreateMaskingTimeline, i4, newPeriodIndexWithoutRemovedPeriods, j2, j3, 4);
        } else if (i4 == -1) {
            playerInfoMaskTimelineAndPositionInfo = maskTimelineAndPositionInfo(playerInfo, timelineCreateMaskingTimeline, SessionPositionInfo.DEFAULT_POSITION_INFO, SessionPositionInfo.DEFAULT, 4);
            i5 = 4;
        } else if (z2) {
            i5 = 4;
            playerInfoMaskTimelineAndPositionInfo = maskTimelineAndPositionInfo(playerInfo, timelineCreateMaskingTimeline, i4, newPeriodIndexWithoutRemovedPeriods, j2, j3, 4);
        } else {
            i5 = 4;
            Timeline.Window window2 = timelineCreateMaskingTimeline.getWindow(i4, new Timeline.Window());
            long defaultPositionMs = window2.getDefaultPositionMs();
            long durationMs = window2.getDurationMs();
            Player.PositionInfo positionInfo = new Player.PositionInfo((Object) null, i4, window2.mediaItem, (Object) null, newPeriodIndexWithoutRemovedPeriods, defaultPositionMs, defaultPositionMs, -1, -1);
            playerInfoMaskTimelineAndPositionInfo = maskTimelineAndPositionInfo(playerInfo, timelineCreateMaskingTimeline, positionInfo, new SessionPositionInfo(positionInfo, false, SystemClock.elapsedRealtime(), durationMs, defaultPositionMs, MediaUtils.calculateBufferedPercentage(defaultPositionMs, durationMs), 0L, -9223372036854775807L, durationMs, defaultPositionMs), 4);
        }
        int i8 = playerInfoMaskTimelineAndPositionInfo.playbackState;
        return (i8 == 1 || i8 == i5 || i2 >= i3 || i3 != timeline.getWindowCount() || currentMediaItemIndexInternal < i2) ? playerInfoMaskTimelineAndPositionInfo : playerInfoMaskTimelineAndPositionInfo.copyWithPlaybackState(i5, null);
    }

    private PlayerInfo maskPositionInfo(PlayerInfo playerInfo, Timeline timeline, PeriodInfo periodInfo) {
        int i2 = playerInfo.sessionPositionInfo.positionInfo.periodIndex;
        int i3 = periodInfo.index;
        Timeline.Period period = new Timeline.Period();
        timeline.getPeriod(i2, period);
        Timeline.Period period2 = new Timeline.Period();
        timeline.getPeriod(i3, period2);
        boolean z2 = i2 != i3;
        long j2 = periodInfo.periodPositionUs;
        long jMsToUs = Util.msToUs(getCurrentPosition()) - period.getPositionInWindowUs();
        if (!z2 && j2 == jMsToUs) {
            return playerInfo;
        }
        Assertions.checkState(playerInfo.sessionPositionInfo.positionInfo.adGroupIndex == -1);
        Player.PositionInfo positionInfo = new Player.PositionInfo((Object) null, period.windowIndex, playerInfo.sessionPositionInfo.positionInfo.mediaItem, (Object) null, i2, Util.usToMs(period.positionInWindowUs + jMsToUs), Util.usToMs(period.positionInWindowUs + jMsToUs), -1, -1);
        timeline.getPeriod(i3, period2);
        Timeline.Window window = new Timeline.Window();
        timeline.getWindow(period2.windowIndex, window);
        long jUsToMs = Util.usToMs(period2.positionInWindowUs + j2);
        Player.PositionInfo positionInfo2 = new Player.PositionInfo((Object) null, period2.windowIndex, window.mediaItem, (Object) null, i3, jUsToMs, jUsToMs, -1, -1);
        PlayerInfo playerInfoCopyWithPositionInfos = playerInfo.copyWithPositionInfos(positionInfo, positionInfo2, 1);
        if (z2 || j2 < jMsToUs) {
            return playerInfoCopyWithPositionInfos.copyWithSessionPositionInfo(new SessionPositionInfo(positionInfo2, false, SystemClock.elapsedRealtime(), window.getDurationMs(), jUsToMs, MediaUtils.calculateBufferedPercentage(jUsToMs, window.getDurationMs()), 0L, -9223372036854775807L, -9223372036854775807L, jUsToMs));
        }
        long jMax = Math.max(0L, Util.msToUs(playerInfoCopyWithPositionInfos.sessionPositionInfo.totalBufferedDurationMs) - (j2 - jMsToUs));
        long jUsToMs2 = Util.usToMs(period2.positionInWindowUs + j2 + jMax);
        return playerInfoCopyWithPositionInfos.copyWithSessionPositionInfo(new SessionPositionInfo(positionInfo2, false, SystemClock.elapsedRealtime(), window.getDurationMs(), jUsToMs2, MediaUtils.calculateBufferedPercentage(jUsToMs2, window.getDurationMs()), Util.usToMs(jMax), -9223372036854775807L, -9223372036854775807L, jUsToMs2));
    }

    private static PlayerInfo maskTimelineAndPositionInfo(PlayerInfo playerInfo, Timeline timeline, int i2, int i3, long j2, long j3, int i4) {
        Player.PositionInfo positionInfo = new Player.PositionInfo((Object) null, i2, timeline.getWindow(i2, new Timeline.Window()).mediaItem, (Object) null, i3, j2, j3, playerInfo.sessionPositionInfo.positionInfo.adGroupIndex, playerInfo.sessionPositionInfo.positionInfo.adIndexInAdGroup);
        boolean z2 = playerInfo.sessionPositionInfo.isPlayingAd;
        long jElapsedRealtime = SystemClock.elapsedRealtime();
        SessionPositionInfo sessionPositionInfo = playerInfo.sessionPositionInfo;
        return maskTimelineAndPositionInfo(playerInfo, timeline, positionInfo, new SessionPositionInfo(positionInfo, z2, jElapsedRealtime, sessionPositionInfo.durationMs, sessionPositionInfo.bufferedPositionMs, sessionPositionInfo.bufferedPercentage, sessionPositionInfo.totalBufferedDurationMs, sessionPositionInfo.currentLiveOffsetMs, sessionPositionInfo.contentDurationMs, sessionPositionInfo.contentBufferedPositionMs), i4);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void maybeNotifySurfaceSizeChanged(final int i2, final int i3) {
        if (this.surfaceSize.getWidth() == i2 && this.surfaceSize.getHeight() == i3) {
            return;
        }
        this.surfaceSize = new Size(i2, i3);
        this.listeners.sendEvent(24, new ListenerSet.Event() { // from class: androidx.media3.session.J0
        });
    }

    private void moveMediaItemsInternal(int i2, int i3, int i4) {
        int i5;
        int i6;
        Timeline timeline = this.playerInfo.timeline;
        int windowCount = timeline.getWindowCount();
        int iMin = Math.min(i3, windowCount);
        int i7 = iMin - i2;
        int iMin2 = Math.min(i4, windowCount - i7);
        if (i2 >= windowCount || i2 == iMin || i2 == iMin2) {
            return;
        }
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (int i8 = 0; i8 < windowCount; i8++) {
            arrayList.add(timeline.getWindow(i8, new Timeline.Window()));
        }
        Util.moveItems(arrayList, i2, iMin, iMin2);
        rebuildPeriods(timeline, arrayList, arrayList2);
        Timeline timelineCreateMaskingTimeline = createMaskingTimeline(arrayList, arrayList2);
        if (timelineCreateMaskingTimeline.isEmpty()) {
            return;
        }
        int currentMediaItemIndex = getCurrentMediaItemIndex();
        if (currentMediaItemIndex >= i2 && currentMediaItemIndex < iMin) {
            i6 = (currentMediaItemIndex - i2) + iMin2;
        } else {
            if (iMin > currentMediaItemIndex || iMin2 <= currentMediaItemIndex) {
                i5 = (iMin <= currentMediaItemIndex || iMin2 > currentMediaItemIndex) ? currentMediaItemIndex : i7 + currentMediaItemIndex;
                Timeline.Window window = new Timeline.Window();
                updatePlayerInfo(maskTimelineAndPositionInfo(this.playerInfo, timelineCreateMaskingTimeline, i5, timelineCreateMaskingTimeline.getWindow(i5, window).firstPeriodIndex + (this.playerInfo.sessionPositionInfo.positionInfo.periodIndex - timeline.getWindow(currentMediaItemIndex, window).firstPeriodIndex), getCurrentPosition(), getContentPosition(), 5), 0, null, null, null);
            }
            i6 = currentMediaItemIndex - i7;
        }
        i5 = i6;
        Timeline.Window window2 = new Timeline.Window();
        updatePlayerInfo(maskTimelineAndPositionInfo(this.playerInfo, timelineCreateMaskingTimeline, i5, timelineCreateMaskingTimeline.getWindow(i5, window2).firstPeriodIndex + (this.playerInfo.sessionPositionInfo.positionInfo.periodIndex - timeline.getWindow(currentMediaItemIndex, window2).firstPeriodIndex), getCurrentPosition(), getContentPosition(), 5), 0, null, null, null);
    }

    private void notifyPlayerInfoListenersWithReasons(PlayerInfo playerInfo, final PlayerInfo playerInfo2, @Nullable final Integer num, @Nullable final Integer num2, @Nullable final Integer num3, @Nullable final Integer num4) {
        if (num != null) {
            this.listeners.queueEvent(0, new ListenerSet.Event() { // from class: androidx.media3.session.P
            });
        }
        if (num3 != null) {
            this.listeners.queueEvent(11, new ListenerSet.Event() { // from class: androidx.media3.session.P
            });
        }
        final MediaItem currentMediaItem = playerInfo2.getCurrentMediaItem();
        if (num4 != null) {
            this.listeners.queueEvent(1, new ListenerSet.Event() { // from class: androidx.media3.session.T
            });
        }
        PlaybackException playbackException = playerInfo.playerError;
        PlaybackException playbackException2 = playerInfo2.playerError;
        if (playbackException != playbackException2 && (playbackException == null || !playbackException.errorInfoEquals(playbackException2))) {
            this.listeners.queueEvent(10, new U(playbackException2));
            if (playbackException2 != null) {
                this.listeners.queueEvent(10, new U(playbackException2));
            }
        }
        if (!playerInfo.currentTracks.equals(playerInfo2.currentTracks)) {
            this.listeners.queueEvent(2, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.mediaMetadata.equals(playerInfo2.mediaMetadata)) {
            this.listeners.queueEvent(14, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.isLoading != playerInfo2.isLoading) {
            this.listeners.queueEvent(3, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.playbackState != playerInfo2.playbackState) {
            this.listeners.queueEvent(4, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (num2 != null) {
            this.listeners.queueEvent(5, new ListenerSet.Event() { // from class: androidx.media3.session.P
            });
        }
        if (playerInfo.playbackSuppressionReason != playerInfo2.playbackSuppressionReason) {
            this.listeners.queueEvent(6, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.isPlaying != playerInfo2.isPlaying) {
            this.listeners.queueEvent(7, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.playbackParameters.equals(playerInfo2.playbackParameters)) {
            this.listeners.queueEvent(12, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.repeatMode != playerInfo2.repeatMode) {
            this.listeners.queueEvent(8, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.shuffleModeEnabled != playerInfo2.shuffleModeEnabled) {
            this.listeners.queueEvent(9, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.playlistMetadata.equals(playerInfo2.playlistMetadata)) {
            this.listeners.queueEvent(15, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.volume != playerInfo2.volume) {
            this.listeners.queueEvent(22, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.audioAttributes.equals(playerInfo2.audioAttributes)) {
            this.listeners.queueEvent(20, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.cueGroup.cues.equals(playerInfo2.cueGroup.cues)) {
            this.listeners.queueEvent(27, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
            this.listeners.queueEvent(27, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.deviceInfo.equals(playerInfo2.deviceInfo)) {
            this.listeners.queueEvent(29, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.deviceVolume != playerInfo2.deviceVolume || playerInfo.deviceMuted != playerInfo2.deviceMuted) {
            this.listeners.queueEvent(30, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.videoSize.equals(playerInfo2.videoSize)) {
            this.listeners.queueEvent(25, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.seekBackIncrementMs != playerInfo2.seekBackIncrementMs) {
            this.listeners.queueEvent(16, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.seekForwardIncrementMs != playerInfo2.seekForwardIncrementMs) {
            this.listeners.queueEvent(17, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (playerInfo.maxSeekToPreviousPositionMs != playerInfo2.maxSeekToPreviousPositionMs) {
            this.listeners.queueEvent(18, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        if (!playerInfo.trackSelectionParameters.equals(playerInfo2.trackSelectionParameters)) {
            this.listeners.queueEvent(19, new ListenerSet.Event() { // from class: androidx.media3.session.Q
            });
        }
        this.listeners.flushEvents();
    }

    private static void rebuildPeriods(Timeline timeline, List<Timeline.Window> list, List<Timeline.Period> list2) {
        for (int i2 = 0; i2 < list.size(); i2++) {
            Timeline.Window window = list.get(i2);
            int i3 = window.firstPeriodIndex;
            int i4 = window.lastPeriodIndex;
            if (i3 == -1 || i4 == -1) {
                window.firstPeriodIndex = list2.size();
                window.lastPeriodIndex = list2.size();
                list2.add(createNewPeriod(i2));
            } else {
                window.firstPeriodIndex = list2.size();
                window.lastPeriodIndex = list2.size() + (i4 - i3);
                while (i3 <= i4) {
                    list2.add(getPeriodWithNewWindowIndex(timeline, i3, i2));
                    i3++;
                }
            }
        }
    }

    private void removeMediaItemsInternal(int i2, int i3) {
        int windowCount = this.playerInfo.timeline.getWindowCount();
        int iMin = Math.min(i3, windowCount);
        if (i2 >= windowCount || i2 == iMin || windowCount == 0) {
            return;
        }
        boolean z2 = getCurrentMediaItemIndex() >= i2 && getCurrentMediaItemIndex() < iMin;
        updatePlayerInfo(maskPlayerInfoForRemovedItems(this.playerInfo, i2, iMin, false, getCurrentPosition(), getContentPosition()), 0, null, z2 ? 4 : null, this.playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex >= i2 && this.playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex < iMin ? 3 : null);
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    private void replaceMediaItemsInternal(int i2, int i3, List<MediaItem> list) throws IllegalSeekPositionException {
        int windowCount = this.playerInfo.timeline.getWindowCount();
        if (i2 > windowCount) {
            return;
        }
        if (this.playerInfo.timeline.isEmpty()) {
            setMediaItemsInternal(list, -1, -9223372036854775807L, false);
            return;
        }
        int iMin = Math.min(i3, windowCount);
        PlayerInfo playerInfoMaskPlayerInfoForRemovedItems = maskPlayerInfoForRemovedItems(maskPlayerInfoForAddedItems(this.playerInfo, iMin, list, getCurrentPosition(), getContentPosition()), i2, iMin, true, getCurrentPosition(), getContentPosition());
        boolean z2 = this.playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex >= i2 && this.playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex < iMin;
        updatePlayerInfo(playerInfoMaskPlayerInfoForRemovedItems, 0, null, z2 ? 4 : null, z2 ? 3 : null);
    }

    private boolean requestConnectToService() {
        int i2 = Build.VERSION.SDK_INT >= 29 ? 4097 : 1;
        Intent intent = new Intent(MediaSessionService.SERVICE_INTERFACE);
        intent.setClassName(this.token.getPackageName(), this.token.getServiceName());
        try {
            if (this.context.bindService(intent, this.serviceConnection, i2)) {
                return true;
            }
            Log.w(TAG, "bind to " + this.token + " failed");
            return false;
        } catch (SecurityException e2) {
            Log.w(TAG, "bind to " + this.token + " not allowed", e2);
            return false;
        }
    }

    private boolean requestConnectToSession(Bundle bundle) {
        try {
            IMediaSession.Stub.asInterface((IBinder) Assertions.checkStateNotNull(this.token.getBinder())).connect(this.controllerStub, this.sequencedFutureManager.obtainNextSequenceNumber(), new ConnectionRequest(this.context.getPackageName(), Process.myPid(), bundle, this.instance.getMaxCommandsForMediaItems()).toBundle());
            return true;
        } catch (RemoteException e2) {
            Log.w(TAG, "Failed to call connection request.", e2);
            return false;
        }
    }

    private static ImmutableList<CommandButton> resolveCustomLayout(List<CommandButton> list, List<CommandButton> list2, Bundle bundle, SessionCommands sessionCommands, Player.Commands commands) {
        if (!list2.isEmpty()) {
            return CommandButton.copyWithUnavailableButtonsDisabled(list2, sessionCommands, commands);
        }
        boolean z2 = false;
        boolean z3 = (bundle.getBoolean("android.media.playback.ALWAYS_RESERVE_SPACE_FOR.ACTION_SKIP_TO_PREVIOUS") || commands.containsAny(new int[]{6, 7})) ? false : true;
        if (!bundle.getBoolean("android.media.playback.ALWAYS_RESERVE_SPACE_FOR.ACTION_SKIP_TO_NEXT") && !commands.containsAny(new int[]{8, 9})) {
            z2 = true;
        }
        return CommandButton.getCustomLayoutFromMediaButtonPreferences(list, z3, z2);
    }

    private static ImmutableList<CommandButton> resolveMediaButtonPreferences(List<CommandButton> list, List<CommandButton> list2, SessionCommands sessionCommands, Player.Commands commands, Bundle bundle) {
        if (list.isEmpty()) {
            list = CommandButton.getMediaButtonPreferencesFromCustomLayout(list2, commands, bundle);
        }
        return CommandButton.copyWithUnavailableButtonsDisabled(list, sessionCommands, commands);
    }

    private static int resolveSubsequentMediaItemIndex(int i2, boolean z2, int i3, Timeline timeline, int i4, int i5) {
        int windowCount = timeline.getWindowCount();
        for (int i6 = 0; i6 < windowCount && (i3 = timeline.getNextWindowIndex(i3, i2, z2)) != -1; i6++) {
            if (i3 < i4 || i3 >= i5) {
                return i3;
            }
        }
        return -1;
    }

    private void seekToInternal(int i2, long j2) {
        PlayerInfo playerInfoMaskPositionInfo;
        MediaControllerImplBase mediaControllerImplBase = this;
        Timeline timeline = mediaControllerImplBase.playerInfo.timeline;
        if ((timeline.isEmpty() || i2 < timeline.getWindowCount()) && !isPlayingAd()) {
            int i3 = getPlaybackState() == 1 ? 1 : 2;
            PlayerInfo playerInfo = mediaControllerImplBase.playerInfo;
            PlayerInfo playerInfoCopyWithPlaybackState = playerInfo.copyWithPlaybackState(i3, playerInfo.playerError);
            PeriodInfo periodInfo = mediaControllerImplBase.getPeriodInfo(timeline, i2, j2);
            if (periodInfo == null) {
                Player.PositionInfo positionInfo = new Player.PositionInfo((Object) null, i2, (MediaItem) null, (Object) null, i2, j2 == -9223372036854775807L ? 0L : j2, j2 == -9223372036854775807L ? 0L : j2, -1, -1);
                PlayerInfo playerInfo2 = mediaControllerImplBase.playerInfo;
                Timeline timeline2 = playerInfo2.timeline;
                boolean z2 = mediaControllerImplBase.playerInfo.sessionPositionInfo.isPlayingAd;
                long jElapsedRealtime = SystemClock.elapsedRealtime();
                SessionPositionInfo sessionPositionInfo = mediaControllerImplBase.playerInfo.sessionPositionInfo;
                playerInfoMaskPositionInfo = maskTimelineAndPositionInfo(playerInfo2, timeline2, positionInfo, new SessionPositionInfo(positionInfo, z2, jElapsedRealtime, sessionPositionInfo.durationMs, j2 == -9223372036854775807L ? 0L : j2, 0, 0L, sessionPositionInfo.currentLiveOffsetMs, sessionPositionInfo.contentDurationMs, j2 == -9223372036854775807L ? 0L : j2), 1);
                mediaControllerImplBase = this;
            } else {
                playerInfoMaskPositionInfo = mediaControllerImplBase.maskPositionInfo(playerInfoCopyWithPlaybackState, timeline, periodInfo);
            }
            boolean z3 = (mediaControllerImplBase.playerInfo.timeline.isEmpty() || playerInfoMaskPositionInfo.sessionPositionInfo.positionInfo.mediaItemIndex == mediaControllerImplBase.playerInfo.sessionPositionInfo.positionInfo.mediaItemIndex) ? false : true;
            if (z3 || playerInfoMaskPositionInfo.sessionPositionInfo.positionInfo.positionMs != mediaControllerImplBase.playerInfo.sessionPositionInfo.positionInfo.positionMs) {
                updatePlayerInfo(playerInfoMaskPositionInfo, null, null, 1, z3 ? 2 : null);
            }
        }
    }

    private void seekToInternalByOffset(long j2) {
        long currentPosition = getCurrentPosition() + j2;
        long duration = getDuration();
        if (duration != -9223372036854775807L) {
            currentPosition = Math.min(currentPosition, duration);
        }
        seekToInternal(getCurrentMediaItemIndex(), Math.max(currentPosition, 0L));
    }

    private void sendControllerResult(int i2, SessionResult sessionResult) {
        IMediaSession iMediaSession = this.iSession;
        if (iMediaSession == null) {
            return;
        }
        try {
            iMediaSession.onControllerResult(this.controllerStub, i2, sessionResult.toBundle());
        } catch (RemoteException unused) {
            Log.w(TAG, "Error in sending");
        }
    }

    private void sendControllerResultWhenReady(final int i2, final ListenableFuture listenableFuture) {
        listenableFuture.addListener(new Runnable() { // from class: androidx.media3.session.m0
            @Override // java.lang.Runnable
            public final void run() {
                this.f2750b.lambda$sendControllerResultWhenReady$107(listenableFuture, i2);
            }
        }, MoreExecutors.directExecutor());
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    /* JADX WARN: Removed duplicated region for block: B:26:0x0090  */
    /* JADX WARN: Removed duplicated region for block: B:41:0x00e3  */
    /* JADX WARN: Removed duplicated region for block: B:50:0x0156  */
    /* JADX WARN: Removed duplicated region for block: B:53:0x016e  */
    /* JADX WARN: Removed duplicated region for block: B:54:0x0174  */
    /* JADX WARN: Removed duplicated region for block: B:61:0x018a  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void setMediaItemsInternal(java.util.List<androidx.media3.common.MediaItem> r62, int r63, long r64, boolean r66) throws androidx.media3.common.IllegalSeekPositionException {
        /*
            Method dump skipped, instruction units count: 407
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: androidx.media3.session.MediaControllerImplBase.setMediaItemsInternal(java.util.List, int, long, boolean):void");
    }

    private void updatePlayerInfo(PlayerInfo playerInfo, @Nullable Integer num, @Nullable Integer num2, @Nullable Integer num3, @Nullable Integer num4) {
        PlayerInfo playerInfo2 = this.playerInfo;
        this.playerInfo = playerInfo;
        notifyPlayerInfoListenersWithReasons(playerInfo2, playerInfo, num, num2, num3, num4);
    }

    private void updateSessionPositionInfoIfNeeded(SessionPositionInfo sessionPositionInfo) {
        if (this.pendingMaskingSequencedFutureNumbers.isEmpty()) {
            SessionPositionInfo sessionPositionInfo2 = this.playerInfo.sessionPositionInfo;
            if (sessionPositionInfo2.eventTimeMs >= sessionPositionInfo.eventTimeMs || !MediaUtils.areSessionPositionInfosInSamePeriodOrAd(sessionPositionInfo, sessionPositionInfo2)) {
                return;
            }
            this.playerInfo = this.playerInfo.copyWithSessionPositionInfo(sessionPositionInfo);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void addListener(Player.Listener listener) {
        this.listeners.add(listener);
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void addMediaItem(final MediaItem mediaItem) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.o0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2787a.lambda$addMediaItem$30(mediaItem, iMediaSession, i2);
                }
            });
            addMediaItemsInternal(getCurrentTimeline().getWindowCount(), Collections.singletonList(mediaItem));
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void addMediaItems(final List<MediaItem> list) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.c1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2616a.lambda$addMediaItems$32(list, iMediaSession, i2);
                }
            });
            addMediaItemsInternal(getCurrentTimeline().getWindowCount(), list);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearMediaItems() {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.j0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2700a.lambda$clearMediaItems$36(iMediaSession, i2);
                }
            });
            removeMediaItemsInternal(0, Integer.MAX_VALUE);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearVideoSurface() {
        if (isPlayerCommandAvailable(27)) {
            clearSurfacesAndCallbacks();
            dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.D
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2273a.lambda$clearVideoSurface$69(iMediaSession, i2);
                }
            });
            maybeNotifySurfaceSizeChanged(0, 0);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
        if (isPlayerCommandAvailable(27) && surfaceHolder != null && this.videoSurfaceHolder == surfaceHolder) {
            clearVideoSurface();
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearVideoSurfaceView(@Nullable SurfaceView surfaceView) {
        if (isPlayerCommandAvailable(27)) {
            clearVideoSurfaceHolder(surfaceView == null ? null : surfaceView.getHolder());
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearVideoTextureView(@Nullable TextureView textureView) {
        if (isPlayerCommandAvailable(27) && textureView != null && this.videoTextureView == textureView) {
            clearVideoSurface();
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void connect() {
        boolean zRequestConnectToService;
        if (this.token.getType() == 0) {
            this.serviceConnection = null;
            zRequestConnectToService = requestConnectToSession(this.connectionHints);
        } else {
            this.serviceConnection = new SessionServiceConnection(this.connectionHints);
            zRequestConnectToService = requestConnectToService();
        }
        if (zRequestConnectToService) {
            return;
        }
        MediaController mediaControllerImplBase = getInstance();
        MediaController mediaControllerImplBase2 = getInstance();
        Objects.requireNonNull(mediaControllerImplBase2);
        mediaControllerImplBase.runOnApplicationLooper(new S(mediaControllerImplBase2));
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Deprecated
    public void decreaseDeviceVolume() {
        if (isPlayerCommandAvailable(26)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.S0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2469a.lambda$decreaseDeviceVolume$59(iMediaSession, i2);
                }
            });
            int i2 = this.playerInfo.deviceVolume - 1;
            if (i2 >= getDeviceInfo().minVolume) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i2, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i2));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public AudioAttributes getAudioAttributes() {
        return this.playerInfo.audioAttributes;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Player.Commands getAvailableCommands() {
        return this.intersectedPlayerCommands;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public SessionCommands getAvailableSessionCommands() {
        return this.sessionCommands;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public IMediaController getBinder() {
        return this.controllerStub;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Nullable
    public MediaBrowserCompat getBrowserCompat() {
        return null;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getBufferedPercentage() {
        return this.playerInfo.sessionPositionInfo.bufferedPercentage;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getBufferedPosition() {
        return this.playerInfo.sessionPositionInfo.bufferedPositionMs;
    }

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

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Nullable
    public SessionToken getConnectedToken() {
        return this.connectedToken;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Bundle getConnectionHints() {
        return this.connectionHints;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getContentBufferedPosition() {
        return this.playerInfo.sessionPositionInfo.contentBufferedPositionMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getContentDuration() {
        return this.playerInfo.sessionPositionInfo.contentDurationMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getContentPosition() {
        SessionPositionInfo sessionPositionInfo = this.playerInfo.sessionPositionInfo;
        return !sessionPositionInfo.isPlayingAd ? getCurrentPosition() : sessionPositionInfo.positionInfo.contentPositionMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Context getContext() {
        return this.context;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getCurrentAdGroupIndex() {
        return this.playerInfo.sessionPositionInfo.positionInfo.adGroupIndex;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getCurrentAdIndexInAdGroup() {
        return this.playerInfo.sessionPositionInfo.positionInfo.adIndexInAdGroup;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public CueGroup getCurrentCues() {
        return this.playerInfo.cueGroup;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getCurrentLiveOffset() {
        return this.playerInfo.sessionPositionInfo.currentLiveOffsetMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getCurrentMediaItemIndex() {
        return getCurrentMediaItemIndexInternal(this.playerInfo);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getCurrentPeriodIndex() {
        return this.playerInfo.sessionPositionInfo.positionInfo.periodIndex;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getCurrentPosition() {
        long updatedCurrentPositionMs = MediaUtils.getUpdatedCurrentPositionMs(this.playerInfo, this.currentPositionMs, this.lastSetPlayWhenReadyCalledTimeMs, getInstance().getTimeDiffMs());
        this.currentPositionMs = updatedCurrentPositionMs;
        return updatedCurrentPositionMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Timeline getCurrentTimeline() {
        return this.playerInfo.timeline;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Tracks getCurrentTracks() {
        return this.playerInfo.currentTracks;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public ImmutableList<CommandButton> getCustomLayout() {
        return this.resolvedCustomLayout;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public DeviceInfo getDeviceInfo() {
        return this.playerInfo.deviceInfo;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getDeviceVolume() {
        return this.playerInfo.deviceVolume;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getDuration() {
        return this.playerInfo.sessionPositionInfo.durationMs;
    }

    MediaController getInstance() {
        return this.instance;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getMaxSeekToPreviousPosition() {
        return this.playerInfo.maxSeekToPreviousPositionMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public ImmutableList<CommandButton> getMediaButtonPreferences() {
        return this.resolvedMediaButtonPreferences;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public MediaMetadata getMediaMetadata() {
        return this.playerInfo.mediaMetadata;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getNextMediaItemIndex() {
        if (this.playerInfo.timeline.isEmpty()) {
            return -1;
        }
        return this.playerInfo.timeline.getNextWindowIndex(getCurrentMediaItemIndex(), convertRepeatModeForNavigation(this.playerInfo.repeatMode), this.playerInfo.shuffleModeEnabled);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean getPlayWhenReady() {
        return this.playerInfo.playWhenReady;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public PlaybackParameters getPlaybackParameters() {
        return this.playerInfo.playbackParameters;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getPlaybackState() {
        return this.playerInfo.playbackState;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getPlaybackSuppressionReason() {
        return this.playerInfo.playbackSuppressionReason;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Nullable
    public PlaybackException getPlayerError() {
        return this.playerInfo.playerError;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public MediaMetadata getPlaylistMetadata() {
        return this.playerInfo.playlistMetadata;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getPreviousMediaItemIndex() {
        if (this.playerInfo.timeline.isEmpty()) {
            return -1;
        }
        return this.playerInfo.timeline.getPreviousWindowIndex(getCurrentMediaItemIndex(), convertRepeatModeForNavigation(this.playerInfo.repeatMode), this.playerInfo.shuffleModeEnabled);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public int getRepeatMode() {
        return this.playerInfo.repeatMode;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getSeekBackIncrement() {
        return this.playerInfo.seekBackIncrementMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getSeekForwardIncrement() {
        return this.playerInfo.seekForwardIncrementMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public PendingIntent getSessionActivity() {
        return this.sessionActivity;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Bundle getSessionExtras() {
        return this.sessionExtras;
    }

    @Nullable
    IMediaSession getSessionInterfaceWithSessionCommandIfAble(int i2) {
        Assertions.checkArgument(i2 != 0);
        if (this.sessionCommands.contains(i2)) {
            return this.iSession;
        }
        Log.w(TAG, "Controller isn't allowed to call command, commandCode=" + i2);
        return null;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean getShuffleModeEnabled() {
        return this.playerInfo.shuffleModeEnabled;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public Size getSurfaceSize() {
        return this.surfaceSize;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public long getTotalBufferedDuration() {
        return this.playerInfo.sessionPositionInfo.totalBufferedDurationMs;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public TrackSelectionParameters getTrackSelectionParameters() {
        return this.playerInfo.trackSelectionParameters;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public VideoSize getVideoSize() {
        return this.playerInfo.videoSize;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public float getVolume() {
        return this.playerInfo.volume;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean hasNextMediaItem() {
        return getNextMediaItemIndex() != -1;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean hasPreviousMediaItem() {
        return getPreviousMediaItemIndex() != -1;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Deprecated
    public void increaseDeviceVolume() {
        if (isPlayerCommandAvailable(26)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.u0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2876a.lambda$increaseDeviceVolume$55(iMediaSession, i2);
                }
            });
            int i2 = this.playerInfo.deviceVolume + 1;
            int i3 = getDeviceInfo().maxVolume;
            if (i3 == 0 || i2 <= i3) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i2, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i2));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean isConnected() {
        return this.iSession != null;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean isDeviceMuted() {
        return this.playerInfo.deviceMuted;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean isLoading() {
        return this.playerInfo.isLoading;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean isPlaying() {
        return this.playerInfo.isPlaying;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public boolean isPlayingAd() {
        return this.playerInfo.sessionPositionInfo.isPlayingAd;
    }

    boolean isReleased() {
        return this.released;
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void moveMediaItem(final int i2, final int i3) {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0 && i3 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.M0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i4) throws RemoteException {
                    this.f2383a.lambda$moveMediaItem$37(i2, i3, iMediaSession, i4);
                }
            });
            moveMediaItemsInternal(i2, i2 + 1, i3);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void moveMediaItems(final int i2, final int i3, final int i4) {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0 && i2 <= i3 && i4 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.b0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i5) throws RemoteException {
                    this.f2596a.lambda$moveMediaItems$38(i2, i3, i4, iMediaSession, i5);
                }
            });
            moveMediaItemsInternal(i2, i3, i4);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void notifyPeriodicSessionPositionInfoChanged(SessionPositionInfo sessionPositionInfo) {
        if (isConnected()) {
            updateSessionPositionInfoIfNeeded(sessionPositionInfo);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onAvailableCommandsChangedFromPlayer(Player.Commands commands) {
        boolean z2;
        boolean z3;
        if (isConnected() && !Objects.equals(this.playerCommandsFromPlayer, commands)) {
            this.playerCommandsFromPlayer = commands;
            Player.Commands commands2 = this.intersectedPlayerCommands;
            Player.Commands commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable = createIntersectedCommandsEnsuringCommandReleaseAvailable(this.playerCommandsFromSession, commands);
            this.intersectedPlayerCommands = commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable;
            if (Objects.equals(commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable, commands2)) {
                z2 = false;
                z3 = false;
            } else {
                ImmutableList<CommandButton> immutableList = this.resolvedMediaButtonPreferences;
                ImmutableList<CommandButton> immutableList2 = this.resolvedCustomLayout;
                ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(this.mediaButtonPreferencesOriginal, this.customLayoutOriginal, this.sessionCommands, this.intersectedPlayerCommands, this.sessionExtras);
                this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
                this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, this.customLayoutOriginal, this.sessionExtras, this.sessionCommands, this.intersectedPlayerCommands);
                z2 = !this.resolvedMediaButtonPreferences.equals(immutableList);
                z3 = !this.resolvedCustomLayout.equals(immutableList2);
                this.listeners.sendEvent(13, new G0(this));
            }
            if (z3) {
                getInstance().notifyControllerListener(new I0(this));
            }
            if (z2) {
                getInstance().notifyControllerListener(new I0(this));
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onAvailableCommandsChangedFromSession(final SessionCommands sessionCommands, Player.Commands commands) {
        boolean z2;
        boolean z3;
        if (isConnected()) {
            boolean zEquals = Objects.equals(this.playerCommandsFromSession, commands);
            boolean zEquals2 = Objects.equals(this.sessionCommands, sessionCommands);
            if (zEquals && zEquals2) {
                return;
            }
            this.sessionCommands = sessionCommands;
            boolean z4 = false;
            if (zEquals) {
                z2 = false;
            } else {
                this.playerCommandsFromSession = commands;
                Player.Commands commands2 = this.intersectedPlayerCommands;
                Player.Commands commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable = createIntersectedCommandsEnsuringCommandReleaseAvailable(commands, this.playerCommandsFromPlayer);
                this.intersectedPlayerCommands = commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable;
                z2 = !Objects.equals(commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable, commands2);
            }
            if (!zEquals2 || z2) {
                ImmutableList<CommandButton> immutableList = this.resolvedMediaButtonPreferences;
                ImmutableList<CommandButton> immutableList2 = this.resolvedCustomLayout;
                ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(this.mediaButtonPreferencesOriginal, this.customLayoutOriginal, sessionCommands, this.intersectedPlayerCommands, this.sessionExtras);
                this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
                this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, this.customLayoutOriginal, this.sessionExtras, sessionCommands, this.intersectedPlayerCommands);
                z3 = !this.resolvedMediaButtonPreferences.equals(immutableList);
                z4 = !this.resolvedCustomLayout.equals(immutableList2);
            } else {
                z3 = false;
            }
            if (z2) {
                this.listeners.sendEvent(13, new G0(this));
            }
            if (!zEquals2) {
                getInstance().notifyControllerListener(new Consumer() { // from class: androidx.media3.session.H0
                });
            }
            if (z4) {
                getInstance().notifyControllerListener(new I0(this));
            }
            if (z3) {
                getInstance().notifyControllerListener(new I0(this));
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onConnected(ConnectionState connectionState) {
        if (this.iSession != null) {
            Log.e(TAG, "Cannot be notified about the connection result many times. Probably a bug or malicious app.");
            getInstance().release();
            return;
        }
        this.iSession = connectionState.sessionBinder;
        this.sessionActivity = connectionState.sessionActivity;
        this.sessionCommands = connectionState.sessionCommands;
        Player.Commands commands = connectionState.playerCommandsFromSession;
        this.playerCommandsFromSession = commands;
        Player.Commands commands2 = connectionState.playerCommandsFromPlayer;
        this.playerCommandsFromPlayer = commands2;
        Player.Commands commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable = createIntersectedCommandsEnsuringCommandReleaseAvailable(commands, commands2);
        this.intersectedPlayerCommands = commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable;
        ImmutableList<CommandButton> immutableList = connectionState.customLayout;
        this.customLayoutOriginal = immutableList;
        ImmutableList<CommandButton> immutableList2 = connectionState.mediaButtonPreferences;
        this.mediaButtonPreferencesOriginal = immutableList2;
        ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(immutableList2, immutableList, this.sessionCommands, commandsCreateIntersectedCommandsEnsuringCommandReleaseAvailable, connectionState.sessionExtras);
        this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
        this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, this.customLayoutOriginal, connectionState.sessionExtras, this.sessionCommands, this.intersectedPlayerCommands);
        ImmutableMap.Builder builder = new ImmutableMap.Builder();
        for (int i2 = 0; i2 < connectionState.commandButtonsForMediaItems.size(); i2++) {
            CommandButton commandButton = (CommandButton) connectionState.commandButtonsForMediaItems.get(i2);
            SessionCommand sessionCommand = commandButton.sessionCommand;
            if (sessionCommand != null && sessionCommand.commandCode == 0) {
                builder.put(sessionCommand.customAction, commandButton);
            }
        }
        this.commandButtonsForMediaItemsMap = builder.buildOrThrow();
        this.playerInfo = connectionState.playerInfo;
        MediaSession.Token platformToken = connectionState.platformToken;
        if (platformToken == null) {
            platformToken = this.token.getPlatformToken();
        }
        MediaSession.Token token = platformToken;
        if (token != null) {
            this.platformController = new android.media.session.MediaController(this.context, token);
        }
        try {
            connectionState.sessionBinder.asBinder().linkToDeath(this.deathRecipient, 0);
            this.connectedToken = new SessionToken(this.token.getUid(), 0, connectionState.libraryVersion, connectionState.sessionInterfaceVersion, this.token.getPackageName(), connectionState.sessionBinder, connectionState.tokenExtras, token);
            this.sessionExtras = connectionState.sessionExtras;
            getInstance().notifyAccepted();
        } catch (RemoteException unused) {
            getInstance().release();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onCustomCommand(final int i2, final SessionCommand sessionCommand, final Bundle bundle) {
        if (isConnected()) {
            getInstance().notifyControllerListener(new Consumer() { // from class: androidx.media3.session.r0
            });
        }
    }

    public void onError(int i2, final SessionError sessionError) {
        if (isConnected()) {
            getInstance().notifyControllerListener(new Consumer() { // from class: androidx.media3.session.F0
            });
        }
    }

    public void onExtrasChanged(final Bundle bundle) {
        if (isConnected()) {
            ImmutableList<CommandButton> immutableList = this.resolvedMediaButtonPreferences;
            ImmutableList<CommandButton> immutableList2 = this.resolvedCustomLayout;
            this.sessionExtras = bundle;
            ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(this.mediaButtonPreferencesOriginal, this.customLayoutOriginal, this.sessionCommands, this.intersectedPlayerCommands, bundle);
            this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
            this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, this.customLayoutOriginal, this.sessionExtras, this.sessionCommands, this.intersectedPlayerCommands);
            final boolean z2 = !this.resolvedMediaButtonPreferences.equals(immutableList);
            final boolean z3 = !this.resolvedCustomLayout.equals(immutableList2);
            getInstance().notifyControllerListener(new Consumer() { // from class: androidx.media3.session.V
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onPlayerInfoChanged(PlayerInfo playerInfo, PlayerInfo.BundlingExclusions bundlingExclusions) {
        if (isConnected()) {
            PlayerInfo playerInfo2 = this.pendingPlayerInfo;
            if (playerInfo2 != null) {
                this.pendingPlayerInfo = MediaUtils.mergePlayerInfo(playerInfo2, playerInfo, bundlingExclusions, this.intersectedPlayerCommands);
                if (!this.pendingMaskingSequencedFutureNumbers.isEmpty()) {
                    return;
                }
                playerInfo = this.pendingPlayerInfo;
                bundlingExclusions = PlayerInfo.BundlingExclusions.NONE;
                this.pendingPlayerInfo = null;
            }
            PlayerInfo playerInfo3 = this.playerInfo;
            PlayerInfo playerInfoMergePlayerInfo = MediaUtils.mergePlayerInfo(playerInfo3, playerInfo, bundlingExclusions, this.intersectedPlayerCommands);
            this.playerInfo = playerInfoMergePlayerInfo;
            Integer numValueOf = (playerInfo3.oldPositionInfo.equals(playerInfo.oldPositionInfo) && playerInfo3.newPositionInfo.equals(playerInfo.newPositionInfo)) ? null : Integer.valueOf(playerInfoMergePlayerInfo.discontinuityReason);
            Integer numValueOf2 = !Objects.equals(playerInfo3.getCurrentMediaItem(), playerInfoMergePlayerInfo.getCurrentMediaItem()) ? Integer.valueOf(playerInfoMergePlayerInfo.mediaItemTransitionReason) : null;
            Integer numValueOf3 = !playerInfo3.timeline.equals(playerInfoMergePlayerInfo.timeline) ? Integer.valueOf(playerInfoMergePlayerInfo.timelineChangeReason) : null;
            int i2 = playerInfo3.playWhenReadyChangeReason;
            int i3 = playerInfoMergePlayerInfo.playWhenReadyChangeReason;
            notifyPlayerInfoListenersWithReasons(playerInfo3, playerInfoMergePlayerInfo, numValueOf3, (i2 == i3 && playerInfo3.playWhenReady == playerInfoMergePlayerInfo.playWhenReady) ? null : Integer.valueOf(i3), numValueOf, numValueOf2);
        }
    }

    public void onRenderedFirstFrame() {
        this.listeners.sendEvent(26, new C0241d0());
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onSetCustomLayout(int i2, List<CommandButton> list) {
        if (isConnected()) {
            ImmutableList<CommandButton> immutableList = this.resolvedMediaButtonPreferences;
            ImmutableList<CommandButton> immutableList2 = this.resolvedCustomLayout;
            this.customLayoutOriginal = ImmutableList.copyOf(list);
            ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(this.mediaButtonPreferencesOriginal, list, this.sessionCommands, this.intersectedPlayerCommands, this.sessionExtras);
            this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
            this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, list, this.sessionExtras, this.sessionCommands, this.intersectedPlayerCommands);
            getInstance().notifyControllerListener(new C0255f0(this, !this.resolvedCustomLayout.equals(immutableList2), !this.resolvedMediaButtonPreferences.equals(immutableList), i2));
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void onSetMediaButtonPreferences(int i2, List<CommandButton> list) {
        if (isConnected()) {
            ImmutableList<CommandButton> immutableList = this.resolvedMediaButtonPreferences;
            ImmutableList<CommandButton> immutableList2 = this.resolvedCustomLayout;
            this.mediaButtonPreferencesOriginal = ImmutableList.copyOf(list);
            ImmutableList<CommandButton> immutableListResolveMediaButtonPreferences = resolveMediaButtonPreferences(list, this.customLayoutOriginal, this.sessionCommands, this.intersectedPlayerCommands, this.sessionExtras);
            this.resolvedMediaButtonPreferences = immutableListResolveMediaButtonPreferences;
            this.resolvedCustomLayout = resolveCustomLayout(immutableListResolveMediaButtonPreferences, this.customLayoutOriginal, this.sessionExtras, this.sessionCommands, this.intersectedPlayerCommands);
            getInstance().notifyControllerListener(new C0255f0(this, !this.resolvedCustomLayout.equals(immutableList2), !this.resolvedMediaButtonPreferences.equals(immutableList), i2));
        }
    }

    public void onSetSessionActivity(int i2, @Nullable final PendingIntent pendingIntent) {
        if (!isConnected() || Objects.equals(this.sessionActivity, pendingIntent)) {
            return;
        }
        this.sessionActivity = pendingIntent;
        getInstance().notifyControllerListener(new Consumer() { // from class: androidx.media3.session.k0
        });
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void pause() {
        if (isPlayerCommandAvailable(1)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.t0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2861a.lambda$pause$6(iMediaSession, i2);
                }
            });
            setPlayWhenReady(false, 1);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void play() {
        android.media.session.MediaController mediaController;
        if (!isPlayerCommandAvailable(1)) {
            Log.w(TAG, "Calling play() omitted due to COMMAND_PLAY_PAUSE not being available. If this play command has started the service for instance for playback resumption, this may prevent the service from being started into the foreground.");
            return;
        }
        if (Build.VERSION.SDK_INT >= 31 && (mediaController = this.platformController) != null) {
            mediaController.getTransportControls().sendCustomAction("androidx.media3.session.SESSION_COMMAND_MEDIA3_PLAY_REQUEST", (Bundle) null);
        }
        dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.y0
            @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
            public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                this.f2937a.lambda$play$5(iMediaSession, i2);
            }
        });
        setPlayWhenReady(true, 1);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void prepare() {
        if (isPlayerCommandAvailable(2)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.B0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2255a.lambda$prepare$7(iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.playbackState == 1) {
                updatePlayerInfo(playerInfo.copyWithPlaybackState(playerInfo.timeline.isEmpty() ? 4 : 2, null), null, null, null, null);
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void release() {
        IMediaSession iMediaSession = this.iSession;
        if (this.released) {
            return;
        }
        this.released = true;
        this.connectedToken = null;
        this.fallbackPlaybackInfoUpdateHandler.removeCallbacksAndMessages(null);
        this.flushCommandQueueHandler.release();
        this.iSession = null;
        if (iMediaSession != null) {
            int iObtainNextSequenceNumber = this.sequencedFutureManager.obtainNextSequenceNumber();
            try {
                iMediaSession.asBinder().unlinkToDeath(this.deathRecipient, 0);
                iMediaSession.release(this.controllerStub, iObtainNextSequenceNumber);
            } catch (RemoteException unused) {
            }
        }
        this.listeners.release();
        this.sequencedFutureManager.lazyRelease(30000L, new Runnable() { // from class: androidx.media3.session.Y
            @Override // java.lang.Runnable
            public final void run() {
                this.f2549b.lambda$release$4();
            }
        });
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void removeListener(Player.Listener listener) {
        this.listeners.remove(listener);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void removeMediaItem(final int i2) {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.g0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2670a.lambda$removeMediaItem$34(i2, iMediaSession, i3);
                }
            });
            removeMediaItemsInternal(i2, i2 + 1);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void removeMediaItems(final int i2, final int i3) {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0 && i3 >= i2);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.O
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i4) throws RemoteException {
                    this.f2411a.lambda$removeMediaItems$35(i2, i3, iMediaSession, i4);
                }
            });
            removeMediaItemsInternal(i2, i3);
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void replaceMediaItem(final int i2, final MediaItem mediaItem) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.b1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2600a.lambda$replaceMediaItem$39(i2, mediaItem, iMediaSession, i3);
                }
            });
            replaceMediaItemsInternal(i2, i2 + 1, ImmutableList.of(mediaItem));
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void replaceMediaItems(final int i2, final int i3, final List<MediaItem> list) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0 && i2 <= i3);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.d1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i4) throws RemoteException {
                    this.f2626a.lambda$replaceMediaItems$40(list, i2, i3, iMediaSession, i4);
                }
            });
            replaceMediaItemsInternal(i2, i3, list);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekBack() {
        if (isPlayerCommandAvailable(11)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.q0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2816a.lambda$seekBack$12(iMediaSession, i2);
                }
            });
            seekToInternalByOffset(-getSeekBackIncrement());
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekForward() {
        if (isPlayerCommandAvailable(12)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.E
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2286a.lambda$seekForward$13(iMediaSession, i2);
                }
            });
            seekToInternalByOffset(getSeekForwardIncrement());
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekTo(final long j2) {
        if (isPlayerCommandAvailable(5)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.C
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2262a.lambda$seekTo$10(j2, iMediaSession, i2);
                }
            });
            seekToInternal(getCurrentMediaItemIndex(), j2);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToDefaultPosition() {
        if (isPlayerCommandAvailable(4)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.N
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2397a.lambda$seekToDefaultPosition$8(iMediaSession, i2);
                }
            });
            seekToInternal(getCurrentMediaItemIndex(), -9223372036854775807L);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToNext() {
        if (isPlayerCommandAvailable(9)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.V0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2512a.lambda$seekToNext$44(iMediaSession, i2);
                }
            });
            Timeline currentTimeline = getCurrentTimeline();
            if (currentTimeline.isEmpty() || isPlayingAd()) {
                return;
            }
            if (hasNextMediaItem()) {
                seekToInternal(getNextMediaItemIndex(), -9223372036854775807L);
                return;
            }
            Timeline.Window window = currentTimeline.getWindow(getCurrentMediaItemIndex(), new Timeline.Window());
            if (window.isDynamic && window.isLive()) {
                seekToInternal(getCurrentMediaItemIndex(), -9223372036854775807L);
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToNextMediaItem() {
        if (isPlayerCommandAvailable(8)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.Q0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2439a.lambda$seekToNextMediaItem$42(iMediaSession, i2);
                }
            });
            if (getNextMediaItemIndex() != -1) {
                seekToInternal(getNextMediaItemIndex(), -9223372036854775807L);
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToPrevious() {
        if (isPlayerCommandAvailable(7)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.h0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2681a.lambda$seekToPrevious$43(iMediaSession, i2);
                }
            });
            Timeline currentTimeline = getCurrentTimeline();
            if (currentTimeline.isEmpty() || isPlayingAd()) {
                return;
            }
            boolean zHasPreviousMediaItem = hasPreviousMediaItem();
            Timeline.Window window = currentTimeline.getWindow(getCurrentMediaItemIndex(), new Timeline.Window());
            if (window.isDynamic && window.isLive()) {
                if (zHasPreviousMediaItem) {
                    seekToInternal(getPreviousMediaItemIndex(), -9223372036854775807L);
                }
            } else if (!zHasPreviousMediaItem || getCurrentPosition() > getMaxSeekToPreviousPosition()) {
                seekToInternal(getCurrentMediaItemIndex(), 0L);
            } else {
                seekToInternal(getPreviousMediaItemIndex(), -9223372036854775807L);
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToPreviousMediaItem() {
        if (isPlayerCommandAvailable(6)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.z0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2948a.lambda$seekToPreviousMediaItem$41(iMediaSession, i2);
                }
            });
            if (getPreviousMediaItemIndex() != -1) {
                seekToInternal(getPreviousMediaItemIndex(), -9223372036854775807L);
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public ListenableFuture sendCustomCommand(final SessionCommand sessionCommand, final Bundle bundle) {
        return dispatchRemoteSessionTaskWithSessionCommand(sessionCommand, new RemoteSessionTask() { // from class: androidx.media3.session.M
            @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
            public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                this.f2380a.lambda$sendCustomCommand$21(sessionCommand, bundle, iMediaSession, i2);
            }
        });
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setAudioAttributes(final AudioAttributes audioAttributes, final boolean z2) {
        if (isPlayerCommandAvailable(35)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.Z0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2562a.lambda$setAudioAttributes$67(audioAttributes, z2, iMediaSession, i2);
                }
            });
            if (this.playerInfo.audioAttributes.equals(audioAttributes)) {
                return;
            }
            this.playerInfo = this.playerInfo.copyWithAudioAttributes(audioAttributes);
            this.listeners.queueEvent(20, new ListenerSet.Event() { // from class: androidx.media3.session.a1
            });
            this.listeners.flushEvents();
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Deprecated
    public void setDeviceMuted(final boolean z2) {
        if (isPlayerCommandAvailable(26)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.C0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2264a.lambda$setDeviceMuted$63(z2, iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.deviceMuted != z2) {
                this.playerInfo = playerInfo.copyWithDeviceVolume(playerInfo.deviceVolume, z2);
                this.listeners.queueEvent(30, new C0220a0(this, z2));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    @Deprecated
    public void setDeviceVolume(final int i2) {
        if (isPlayerCommandAvailable(25)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.R0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2457a.lambda$setDeviceVolume$51(i2, iMediaSession, i3);
                }
            });
            DeviceInfo deviceInfo = getDeviceInfo();
            if (this.playerInfo.deviceVolume == i2 || deviceInfo.minVolume > i2) {
                return;
            }
            if (deviceInfo.maxVolume == 0 || i2 <= deviceInfo.maxVolume) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i2, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i2));
                this.listeners.flushEvents();
            }
        }
    }

    <T> void setFutureResult(final int i2, T t2) {
        this.sequencedFutureManager.setFutureResult(i2, t2);
        getInstance().runOnApplicationLooper(new Runnable() { // from class: androidx.media3.session.v0
            @Override // java.lang.Runnable
            public final void run() {
                this.f2891b.lambda$setFutureResult$106(i2);
            }
        });
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItem(final MediaItem mediaItem) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(31)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.I
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2336a.lambda$setMediaItem$22(mediaItem, iMediaSession, i2);
                }
            });
            setMediaItemsInternal(Collections.singletonList(mediaItem), -1, -9223372036854775807L, true);
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItems(final List<MediaItem> list) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.G
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2308a.lambda$setMediaItems$25(list, iMediaSession, i2);
                }
            });
            setMediaItemsInternal(list, -1, -9223372036854775807L, true);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setPlayWhenReady(final boolean z2) {
        if (isPlayerCommandAvailable(1)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.L0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2370a.lambda$setPlayWhenReady$14(z2, iMediaSession, i2);
                }
            });
            setPlayWhenReady(z2, 1);
        } else if (z2) {
            Log.w(TAG, "Calling play() omitted due to COMMAND_PLAY_PAUSE not being available. If this play command has started the service for instance for playback resumption, this may prevent the service from being started into the foreground.");
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setPlaybackParameters(final PlaybackParameters playbackParameters) {
        if (isPlayerCommandAvailable(13)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.A
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2242a.lambda$setPlaybackParameters$15(playbackParameters, iMediaSession, i2);
                }
            });
            if (this.playerInfo.playbackParameters.equals(playbackParameters)) {
                return;
            }
            this.playerInfo = this.playerInfo.copyWithPlaybackParameters(playbackParameters);
            this.listeners.queueEvent(12, new B(playbackParameters));
            this.listeners.flushEvents();
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setPlaybackSpeed(final float f2) {
        if (isPlayerCommandAvailable(13)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.X
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2536a.lambda$setPlaybackSpeed$17(f2, iMediaSession, i2);
                }
            });
            if (this.playerInfo.playbackParameters.speed != f2) {
                PlaybackParameters playbackParametersWithSpeed = this.playerInfo.playbackParameters.withSpeed(f2);
                this.playerInfo = this.playerInfo.copyWithPlaybackParameters(playbackParametersWithSpeed);
                this.listeners.queueEvent(12, new B(playbackParametersWithSpeed));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setPlaylistMetadata(final MediaMetadata mediaMetadata) {
        if (isPlayerCommandAvailable(19)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.F
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2296a.lambda$setPlaylistMetadata$28(mediaMetadata, iMediaSession, i2);
                }
            });
            if (this.playerInfo.playlistMetadata.equals(mediaMetadata)) {
                return;
            }
            this.playerInfo = this.playerInfo.copyWithPlaylistMetadata(mediaMetadata);
            this.listeners.queueEvent(15, new ListenerSet.Event() { // from class: androidx.media3.session.H
            });
            this.listeners.flushEvents();
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public ListenableFuture setRating(final String str, final Rating rating) {
        return dispatchRemoteSessionTaskWithSessionCommand(SessionCommand.COMMAND_CODE_SESSION_SET_RATING, new RemoteSessionTask() { // from class: androidx.media3.session.J
            @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
            public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                this.f2344a.lambda$setRating$19(str, rating, iMediaSession, i2);
            }
        });
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setRepeatMode(final int i2) {
        if (isPlayerCommandAvailable(15)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.N0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2398a.lambda$setRepeatMode$45(i2, iMediaSession, i3);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.repeatMode != i2) {
                this.playerInfo = playerInfo.copyWithRepeatMode(i2);
                this.listeners.queueEvent(8, new ListenerSet.Event() { // from class: androidx.media3.session.O0
                });
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setShuffleModeEnabled(final boolean z2) {
        if (isPlayerCommandAvailable(14)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.c0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2614a.lambda$setShuffleModeEnabled$47(z2, iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.shuffleModeEnabled != z2) {
                this.playerInfo = playerInfo.copyWithShuffleModeEnabled(z2);
                this.listeners.queueEvent(9, new ListenerSet.Event() { // from class: androidx.media3.session.e0
                });
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setTrackSelectionParameters(final TrackSelectionParameters trackSelectionParameters) {
        if (isPlayerCommandAvailable(29)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.T0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2484a.lambda$setTrackSelectionParameters$75(trackSelectionParameters, iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (trackSelectionParameters != playerInfo.trackSelectionParameters) {
                this.playerInfo = playerInfo.copyWithTrackSelectionParameters(trackSelectionParameters);
                this.listeners.queueEvent(19, new ListenerSet.Event() { // from class: androidx.media3.session.U0
                });
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setVideoSurface(@Nullable final Surface surface) {
        if (isPlayerCommandAvailable(27)) {
            clearSurfacesAndCallbacks();
            this.videoSurface = surface;
            dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.x
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2921a.lambda$setVideoSurface$70(surface, iMediaSession, i2);
                }
            });
            int i2 = surface == null ? 0 : -1;
            maybeNotifySurfaceSizeChanged(i2, i2);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
        if (isPlayerCommandAvailable(27)) {
            if (surfaceHolder == null) {
                clearVideoSurface();
                return;
            }
            if (this.videoSurfaceHolder == surfaceHolder) {
                return;
            }
            clearSurfacesAndCallbacks();
            this.videoSurfaceHolder = surfaceHolder;
            surfaceHolder.addCallback(this.surfaceCallback);
            final Surface surface = surfaceHolder.getSurface();
            if (surface == null || !surface.isValid()) {
                this.videoSurface = null;
                dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.L
                    @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                    public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                        this.f2369a.lambda$setVideoSurfaceHolder$72(iMediaSession, i2);
                    }
                });
                maybeNotifySurfaceSizeChanged(0, 0);
            } else {
                this.videoSurface = surface;
                dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.K
                    @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                    public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                        this.f2358a.lambda$setVideoSurfaceHolder$71(surface, iMediaSession, i2);
                    }
                });
                Rect surfaceFrame = surfaceHolder.getSurfaceFrame();
                maybeNotifySurfaceSizeChanged(surfaceFrame.width(), surfaceFrame.height());
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setVideoSurfaceView(@Nullable SurfaceView surfaceView) {
        if (isPlayerCommandAvailable(27)) {
            setVideoSurfaceHolder(surfaceView == null ? null : surfaceView.getHolder());
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setVideoTextureView(@Nullable TextureView textureView) {
        if (isPlayerCommandAvailable(27)) {
            if (textureView == null) {
                clearVideoSurface();
                return;
            }
            if (this.videoTextureView == textureView) {
                return;
            }
            clearSurfacesAndCallbacks();
            this.videoTextureView = textureView;
            textureView.setSurfaceTextureListener(this.surfaceCallback);
            SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
            if (surfaceTexture == null) {
                dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.X0
                    @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                    public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                        this.f2538a.lambda$setVideoTextureView$73(iMediaSession, i2);
                    }
                });
                maybeNotifySurfaceSizeChanged(0, 0);
            } else {
                this.videoSurface = new Surface(surfaceTexture);
                dispatchRemoteSessionTaskWithPlayerCommandAndWaitForFuture(new RemoteSessionTask() { // from class: androidx.media3.session.Y0
                    @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                    public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                        this.f2550a.lambda$setVideoTextureView$74(iMediaSession, i2);
                    }
                });
                maybeNotifySurfaceSizeChanged(textureView.getWidth(), textureView.getHeight());
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setVolume(final float f2) {
        if (isPlayerCommandAvailable(24)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.D0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2274a.lambda$setVolume$49(f2, iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.volume != f2) {
                this.playerInfo = playerInfo.copyWithVolume(f2);
                this.listeners.queueEvent(22, new ListenerSet.Event() { // from class: androidx.media3.session.E0
                });
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void stop() {
        if (isPlayerCommandAvailable(3)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.A0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2244a.lambda$stop$2(iMediaSession, i2);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            SessionPositionInfo sessionPositionInfo = this.playerInfo.sessionPositionInfo;
            Player.PositionInfo positionInfo = sessionPositionInfo.positionInfo;
            boolean z2 = sessionPositionInfo.isPlayingAd;
            long jElapsedRealtime = SystemClock.elapsedRealtime();
            SessionPositionInfo sessionPositionInfo2 = this.playerInfo.sessionPositionInfo;
            long j2 = sessionPositionInfo2.durationMs;
            long j3 = sessionPositionInfo2.positionInfo.positionMs;
            int iCalculateBufferedPercentage = MediaUtils.calculateBufferedPercentage(this.playerInfo.sessionPositionInfo.positionInfo.positionMs, this.playerInfo.sessionPositionInfo.durationMs);
            SessionPositionInfo sessionPositionInfo3 = this.playerInfo.sessionPositionInfo;
            PlayerInfo playerInfoCopyWithSessionPositionInfo = playerInfo.copyWithSessionPositionInfo(new SessionPositionInfo(positionInfo, z2, jElapsedRealtime, j2, j3, iCalculateBufferedPercentage, 0L, sessionPositionInfo3.currentLiveOffsetMs, sessionPositionInfo3.contentDurationMs, sessionPositionInfo3.positionInfo.positionMs));
            this.playerInfo = playerInfoCopyWithSessionPositionInfo;
            if (playerInfoCopyWithSessionPositionInfo.playbackState != 1) {
                this.playerInfo = playerInfoCopyWithSessionPositionInfo.copyWithPlaybackState(1, playerInfoCopyWithSessionPositionInfo.playerError);
                this.listeners.queueEvent(4, new C0241d0());
                this.listeners.flushEvents();
            }
        }
    }

    private ListenableFuture dispatchRemoteSessionTaskWithSessionCommand(SessionCommand sessionCommand, RemoteSessionTask remoteSessionTask) {
        return dispatchRemoteSessionTaskWithSessionCommandInternal(0, sessionCommand, remoteSessionTask);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public ListenableFuture setRating(final Rating rating) {
        return dispatchRemoteSessionTaskWithSessionCommand(SessionCommand.COMMAND_CODE_SESSION_SET_RATING, new RemoteSessionTask() { // from class: androidx.media3.session.W0
            @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
            public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                this.f2524a.lambda$setRating$20(rating, iMediaSession, i2);
            }
        });
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void addMediaItems(final int i2, final List<MediaItem> list) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.s0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2844a.lambda$addMediaItems$33(i2, list, iMediaSession, i3);
                }
            });
            addMediaItemsInternal(i2, list);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekTo(final int i2, final long j2) {
        if (isPlayerCommandAvailable(10)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.w0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2907a.lambda$seekTo$11(i2, j2, iMediaSession, i3);
                }
            });
            seekToInternal(i2, j2);
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void seekToDefaultPosition(final int i2) {
        if (isPlayerCommandAvailable(10)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.v
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2889a.lambda$seekToDefaultPosition$9(i2, iMediaSession, i3);
                }
            });
            seekToInternal(i2, -9223372036854775807L);
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItems(final List<MediaItem> list, final boolean z2) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.i0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2690a.lambda$setMediaItems$26(list, z2, iMediaSession, i2);
                }
            });
            setMediaItemsInternal(list, -1, -9223372036854775807L, z2);
        }
    }

    private void setPlayWhenReady(boolean z2, int i2) {
        int playbackSuppressionReason = getPlaybackSuppressionReason();
        if (playbackSuppressionReason == 1) {
            playbackSuppressionReason = 0;
        }
        PlayerInfo playerInfo = this.playerInfo;
        if (playerInfo.playWhenReady == z2 && playerInfo.playbackSuppressionReason == playbackSuppressionReason) {
            return;
        }
        this.currentPositionMs = MediaUtils.getUpdatedCurrentPositionMs(playerInfo, this.currentPositionMs, this.lastSetPlayWhenReadyCalledTimeMs, getInstance().getTimeDiffMs());
        this.lastSetPlayWhenReadyCalledTimeMs = SystemClock.elapsedRealtime();
        updatePlayerInfo(this.playerInfo.copyWithPlayWhenReady(z2, i2, playbackSuppressionReason), null, Integer.valueOf(i2), null, null);
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void addMediaItem(final int i2, final MediaItem mediaItem) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            Assertions.checkArgument(i2 >= 0);
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.e1
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2643a.lambda$addMediaItem$31(i2, mediaItem, iMediaSession, i3);
                }
            });
            addMediaItemsInternal(i2, Collections.singletonList(mediaItem));
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void clearVideoSurface(@Nullable Surface surface) {
        if (isPlayerCommandAvailable(27) && surface != null && this.videoSurface == surface) {
            clearVideoSurface();
        }
    }

    @Nullable
    IMediaSession getSessionInterfaceWithSessionCommandIfAble(SessionCommand sessionCommand) {
        Assertions.checkArgument(sessionCommand.commandCode == 0);
        if (!this.sessionCommands.contains(sessionCommand)) {
            Log.w(TAG, "Controller isn't allowed to call custom session command:" + sessionCommand.customAction);
            return null;
        }
        return this.iSession;
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItem(final MediaItem mediaItem, final long j2) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(31)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.K0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2360a.lambda$setMediaItem$23(mediaItem, j2, iMediaSession, i2);
                }
            });
            setMediaItemsInternal(Collections.singletonList(mediaItem), -1, j2, false);
        }
    }

    private static PlayerInfo maskTimelineAndPositionInfo(PlayerInfo playerInfo, Timeline timeline, Player.PositionInfo positionInfo, SessionPositionInfo sessionPositionInfo, int i2) {
        return new PlayerInfo.Builder(playerInfo).setTimeline(timeline).setOldPositionInfo(playerInfo.sessionPositionInfo.positionInfo).setNewPositionInfo(positionInfo).setSessionPositionInfo(sessionPositionInfo).setDiscontinuityReason(i2).build();
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setDeviceMuted(final boolean z2, final int i2) {
        if (isPlayerCommandAvailable(34)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.Z
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2559a.lambda$setDeviceMuted$65(z2, i2, iMediaSession, i3);
                }
            });
            PlayerInfo playerInfo = this.playerInfo;
            if (playerInfo.deviceMuted != z2) {
                this.playerInfo = playerInfo.copyWithDeviceVolume(playerInfo.deviceVolume, z2);
                this.listeners.queueEvent(30, new C0220a0(this, z2));
                this.listeners.flushEvents();
            }
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItems(final List<MediaItem> list, final int i2, final long j2) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(20)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.w
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2903a.lambda$setMediaItems$27(list, i2, j2, iMediaSession, i3);
                }
            });
            setMediaItemsInternal(list, i2, j2, false);
        }
    }

    @Nullable
    private static PeriodInfo getPeriodInfo(Timeline timeline, Timeline.Window window, Timeline.Period period, int i2, long j2) {
        Assertions.checkIndex(i2, 0, timeline.getWindowCount());
        timeline.getWindow(i2, window);
        if (j2 == -9223372036854775807L) {
            j2 = window.getDefaultPositionUs();
            if (j2 == -9223372036854775807L) {
                return null;
            }
        }
        int i3 = window.firstPeriodIndex;
        timeline.getPeriod(i3, period);
        while (i3 < window.lastPeriodIndex && period.positionInWindowUs != j2) {
            int i4 = i3 + 1;
            if (timeline.getPeriod(i4, period).positionInWindowUs > j2) {
                break;
            }
            i3 = i4;
        }
        timeline.getPeriod(i3, period);
        return new PeriodInfo(i3, j2 - period.positionInWindowUs);
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void decreaseDeviceVolume(final int i2) {
        if (isPlayerCommandAvailable(34)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.y
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2935a.lambda$decreaseDeviceVolume$61(i2, iMediaSession, i3);
                }
            });
            int i3 = this.playerInfo.deviceVolume - 1;
            if (i3 >= getDeviceInfo().minVolume) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i3, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i3));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void increaseDeviceVolume(final int i2) {
        if (isPlayerCommandAvailable(34)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.x0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i3) throws RemoteException {
                    this.f2923a.lambda$increaseDeviceVolume$57(i2, iMediaSession, i3);
                }
            });
            int i3 = this.playerInfo.deviceVolume + 1;
            int i4 = getDeviceInfo().maxVolume;
            if (i4 == 0 || i3 <= i4) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i3, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i3));
                this.listeners.flushEvents();
            }
        }
    }

    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setDeviceVolume(final int i2, final int i3) {
        if (isPlayerCommandAvailable(33)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.W
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i4) throws RemoteException {
                    this.f2521a.lambda$setDeviceVolume$53(i2, i3, iMediaSession, i4);
                }
            });
            DeviceInfo deviceInfo = getDeviceInfo();
            if (this.playerInfo.deviceVolume == i2 || deviceInfo.minVolume > i2) {
                return;
            }
            if (deviceInfo.maxVolume == 0 || i2 <= deviceInfo.maxVolume) {
                PlayerInfo playerInfo = this.playerInfo;
                this.playerInfo = playerInfo.copyWithDeviceVolume(i2, playerInfo.deviceMuted);
                this.listeners.queueEvent(30, new C0388z(this, i2));
                this.listeners.flushEvents();
            }
        }
    }

    /* JADX INFO: Thrown type has an unknown type hierarchy: androidx.media3.common.IllegalSeekPositionException */
    @Override // androidx.media3.session.MediaController.MediaControllerImpl
    public void setMediaItem(final MediaItem mediaItem, final boolean z2) throws IllegalSeekPositionException {
        if (isPlayerCommandAvailable(31)) {
            dispatchRemoteSessionTaskWithPlayerCommand(new RemoteSessionTask() { // from class: androidx.media3.session.P0
                @Override // androidx.media3.session.MediaControllerImplBase.RemoteSessionTask
                public final void run(IMediaSession iMediaSession, int i2) throws RemoteException {
                    this.f2430a.lambda$setMediaItem$24(mediaItem, z2, iMediaSession, i2);
                }
            });
            setMediaItemsInternal(Collections.singletonList(mediaItem), -1, -9223372036854775807L, z2);
        }
    }
}