package androidx.media3.session;

import android.os.Looper;
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.media3.common.AudioAttributes;
import androidx.media3.common.DeviceInfo;
import androidx.media3.common.ForwardingPlayer;
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.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.Size;
import androidx.media3.common.util.Util;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
final class PlayerWrapper extends ForwardingPlayer {

    private static final class CurrentMediaItemOnlyTimeline extends Timeline {
        private static final Object UID = new Object();
        private final long durationUs;
        private final boolean isDynamic;
        private final boolean isPlaceholder;
        private final boolean isSeekable;

        @Nullable
        private final MediaItem.LiveConfiguration liveConfiguration;

        @Nullable
        private final MediaItem mediaItem;

        public CurrentMediaItemOnlyTimeline(PlayerWrapper playerWrapper) {
            this.mediaItem = playerWrapper.getCurrentMediaItem();
            this.isSeekable = playerWrapper.isCurrentMediaItemSeekable();
            this.isDynamic = playerWrapper.isCurrentMediaItemDynamic();
            this.isPlaceholder = !playerWrapper.getCurrentTimeline().isEmpty() && playerWrapper.getCurrentTimeline().getWindow(playerWrapper.getCurrentMediaItemIndex(), new Timeline.Window()).isPlaceholder;
            this.liveConfiguration = playerWrapper.isCurrentMediaItemLive() ? MediaItem.LiveConfiguration.UNSET : null;
            this.durationUs = Util.msToUs(playerWrapper.getContentDuration());
        }

        public int getIndexOfPeriod(Object obj) {
            return UID.equals(obj) ? 0 : -1;
        }

        public Timeline.Period getPeriod(int i2, Timeline.Period period, boolean z2) {
            Object obj = UID;
            period.set(obj, obj, 0, this.durationUs, 0L);
            period.isPlaceholder = this.isPlaceholder;
            return period;
        }

        public int getPeriodCount() {
            return 1;
        }

        public Object getUidOfPeriod(int i2) {
            return UID;
        }

        public Timeline.Window getWindow(int i2, Timeline.Window window, long j2) {
            window.set(UID, this.mediaItem, (Object) null, -9223372036854775807L, -9223372036854775807L, -9223372036854775807L, this.isSeekable, this.isDynamic, this.liveConfiguration, 0L, this.durationUs, 0, 0, 0L);
            window.isPlaceholder = this.isPlaceholder;
            return window;
        }

        public int getWindowCount() {
            return 1;
        }
    }

    public PlayerWrapper(Player player) {
        super(player);
    }

    private void verifyApplicationThread() {
        Assertions.checkState(Looper.myLooper() == getApplicationLooper());
    }

    public void addListener(Player.Listener listener) {
        verifyApplicationThread();
        super.addListener(listener);
    }

    public void addMediaItem(MediaItem mediaItem) {
        verifyApplicationThread();
        super.addMediaItem(mediaItem);
    }

    public void addMediaItems(List<MediaItem> list) {
        verifyApplicationThread();
        super.addMediaItems(list);
    }

    public void clearMediaItems() {
        verifyApplicationThread();
        super.clearMediaItems();
    }

    public void clearVideoSurface() {
        verifyApplicationThread();
        super.clearVideoSurface();
    }

    public void clearVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
        verifyApplicationThread();
        super.clearVideoSurfaceHolder(surfaceHolder);
    }

    public void clearVideoSurfaceView(@Nullable SurfaceView surfaceView) {
        verifyApplicationThread();
        super.clearVideoSurfaceView(surfaceView);
    }

    public void clearVideoTextureView(@Nullable TextureView textureView) {
        verifyApplicationThread();
        super.clearVideoTextureView(textureView);
    }

    public PlayerInfo createInitialPlayerInfo() {
        return new PlayerInfo(getPlayerError(), 0, createSessionPositionInfo(), createPositionInfo(), createPositionInfo(), 0, getPlaybackParameters(), getRepeatMode(), getShuffleModeEnabled(), getVideoSize(), getCurrentTimelineWithCommandCheck(), 0, getPlaylistMetadataWithCommandCheck(), getVolumeWithCommandCheck(), getAudioAttributesWithCommandCheck(), getCurrentCuesWithCommandCheck(), getDeviceInfo(), getDeviceVolumeWithCommandCheck(), isDeviceMutedWithCommandCheck(), getPlayWhenReady(), 1, getPlaybackSuppressionReason(), getPlaybackState(), isPlaying(), isLoading(), getMediaMetadataWithCommandCheck(), getSeekBackIncrement(), getSeekForwardIncrement(), getMaxSeekToPreviousPosition(), getCurrentTracksWithCommandCheck(), getTrackSelectionParameters());
    }

    public Player.PositionInfo createPositionInfo() {
        boolean zIsCommandAvailable = isCommandAvailable(16);
        boolean zIsCommandAvailable2 = isCommandAvailable(17);
        return new Player.PositionInfo((Object) null, zIsCommandAvailable2 ? getCurrentMediaItemIndex() : 0, zIsCommandAvailable ? getCurrentMediaItem() : null, (Object) null, zIsCommandAvailable2 ? getCurrentPeriodIndex() : 0, zIsCommandAvailable ? getCurrentPosition() : 0L, zIsCommandAvailable ? getContentPosition() : 0L, zIsCommandAvailable ? getCurrentAdGroupIndex() : -1, zIsCommandAvailable ? getCurrentAdIndexInAdGroup() : -1);
    }

    public SessionPositionInfo createSessionPositionInfo() {
        boolean zIsCommandAvailable = isCommandAvailable(16);
        return new SessionPositionInfo(createPositionInfo(), zIsCommandAvailable && isPlayingAd(), SystemClock.elapsedRealtime(), zIsCommandAvailable ? getDuration() : -9223372036854775807L, zIsCommandAvailable ? getBufferedPosition() : 0L, zIsCommandAvailable ? getBufferedPercentage() : 0, zIsCommandAvailable ? getTotalBufferedDuration() : 0L, zIsCommandAvailable ? getCurrentLiveOffset() : -9223372036854775807L, zIsCommandAvailable ? getContentDuration() : -9223372036854775807L, zIsCommandAvailable ? getContentBufferedPosition() : 0L);
    }

    @Deprecated
    public void decreaseDeviceVolume() {
        verifyApplicationThread();
        super.decreaseDeviceVolume();
    }

    public AudioAttributes getAudioAttributes() {
        verifyApplicationThread();
        return super.getAudioAttributes();
    }

    public AudioAttributes getAudioAttributesWithCommandCheck() {
        return isCommandAvailable(21) ? getAudioAttributes() : AudioAttributes.DEFAULT;
    }

    public Player.Commands getAvailableCommands() {
        verifyApplicationThread();
        return super.getAvailableCommands();
    }

    public int getBufferedPercentage() {
        verifyApplicationThread();
        return super.getBufferedPercentage();
    }

    public long getBufferedPosition() {
        verifyApplicationThread();
        return super.getBufferedPosition();
    }

    public long getContentBufferedPosition() {
        verifyApplicationThread();
        return super.getContentBufferedPosition();
    }

    public long getContentDuration() {
        verifyApplicationThread();
        return super.getContentDuration();
    }

    public long getContentPosition() {
        verifyApplicationThread();
        return super.getContentPosition();
    }

    public int getCurrentAdGroupIndex() {
        verifyApplicationThread();
        return super.getCurrentAdGroupIndex();
    }

    public int getCurrentAdIndexInAdGroup() {
        verifyApplicationThread();
        return super.getCurrentAdIndexInAdGroup();
    }

    public CueGroup getCurrentCues() {
        verifyApplicationThread();
        return super.getCurrentCues();
    }

    public CueGroup getCurrentCuesWithCommandCheck() {
        return isCommandAvailable(28) ? getCurrentCues() : CueGroup.EMPTY_TIME_ZERO;
    }

    public long getCurrentLiveOffset() {
        verifyApplicationThread();
        return super.getCurrentLiveOffset();
    }

    @Nullable
    public Object getCurrentManifest() {
        verifyApplicationThread();
        return super.getCurrentManifest();
    }

    @Nullable
    public MediaItem getCurrentMediaItem() {
        verifyApplicationThread();
        return super.getCurrentMediaItem();
    }

    public int getCurrentMediaItemIndex() {
        verifyApplicationThread();
        return super.getCurrentMediaItemIndex();
    }

    @Nullable
    public MediaItem getCurrentMediaItemWithCommandCheck() {
        if (isCommandAvailable(16)) {
            return getCurrentMediaItem();
        }
        return null;
    }

    public int getCurrentPeriodIndex() {
        verifyApplicationThread();
        return super.getCurrentPeriodIndex();
    }

    public long getCurrentPosition() {
        verifyApplicationThread();
        return super.getCurrentPosition();
    }

    public Timeline getCurrentTimeline() {
        verifyApplicationThread();
        return super.getCurrentTimeline();
    }

    public Timeline getCurrentTimelineWithCommandCheck() {
        if (isCommandAvailable(17)) {
            return getCurrentTimeline();
        }
        if (isCommandAvailable(16) && !getCurrentTimeline().isEmpty()) {
            return new CurrentMediaItemOnlyTimeline(this);
        }
        return Timeline.EMPTY;
    }

    public Tracks getCurrentTracks() {
        verifyApplicationThread();
        return super.getCurrentTracks();
    }

    public Tracks getCurrentTracksWithCommandCheck() {
        return isCommandAvailable(30) ? getCurrentTracks() : Tracks.EMPTY;
    }

    @Deprecated
    public int getCurrentWindowIndex() {
        verifyApplicationThread();
        return super.getCurrentWindowIndex();
    }

    public DeviceInfo getDeviceInfo() {
        verifyApplicationThread();
        return super.getDeviceInfo();
    }

    public int getDeviceVolume() {
        verifyApplicationThread();
        return super.getDeviceVolume();
    }

    public int getDeviceVolumeWithCommandCheck() {
        if (isCommandAvailable(23)) {
            return getDeviceVolume();
        }
        return 0;
    }

    public long getDuration() {
        verifyApplicationThread();
        return super.getDuration();
    }

    public long getDurationWithCommandCheck() {
        if (isCommandAvailable(16)) {
            return getDuration();
        }
        return -9223372036854775807L;
    }

    public long getMaxSeekToPreviousPosition() {
        verifyApplicationThread();
        return super.getMaxSeekToPreviousPosition();
    }

    public MediaItem getMediaItemAt(int i2) {
        verifyApplicationThread();
        return super.getMediaItemAt(i2);
    }

    public int getMediaItemCount() {
        verifyApplicationThread();
        return super.getMediaItemCount();
    }

    public MediaMetadata getMediaMetadata() {
        verifyApplicationThread();
        return super.getMediaMetadata();
    }

    public MediaMetadata getMediaMetadataWithCommandCheck() {
        return isCommandAvailable(18) ? getMediaMetadata() : MediaMetadata.EMPTY;
    }

    public int getNextMediaItemIndex() {
        verifyApplicationThread();
        return super.getNextMediaItemIndex();
    }

    @Deprecated
    public int getNextWindowIndex() {
        verifyApplicationThread();
        return super.getNextWindowIndex();
    }

    public boolean getPlayWhenReady() {
        verifyApplicationThread();
        return super.getPlayWhenReady();
    }

    public PlaybackParameters getPlaybackParameters() {
        verifyApplicationThread();
        return super.getPlaybackParameters();
    }

    public int getPlaybackState() {
        verifyApplicationThread();
        return super.getPlaybackState();
    }

    public int getPlaybackSuppressionReason() {
        verifyApplicationThread();
        return super.getPlaybackSuppressionReason();
    }

    @Nullable
    public PlaybackException getPlayerError() {
        verifyApplicationThread();
        return super.getPlayerError();
    }

    public MediaMetadata getPlaylistMetadata() {
        verifyApplicationThread();
        return super.getPlaylistMetadata();
    }

    public MediaMetadata getPlaylistMetadataWithCommandCheck() {
        return isCommandAvailable(18) ? getPlaylistMetadata() : MediaMetadata.EMPTY;
    }

    public int getPreviousMediaItemIndex() {
        verifyApplicationThread();
        return super.getPreviousMediaItemIndex();
    }

    @Deprecated
    public int getPreviousWindowIndex() {
        verifyApplicationThread();
        return super.getPreviousWindowIndex();
    }

    public int getRepeatMode() {
        verifyApplicationThread();
        return super.getRepeatMode();
    }

    public long getSeekBackIncrement() {
        verifyApplicationThread();
        return super.getSeekBackIncrement();
    }

    public long getSeekForwardIncrement() {
        verifyApplicationThread();
        return super.getSeekForwardIncrement();
    }

    public boolean getShuffleModeEnabled() {
        verifyApplicationThread();
        return super.getShuffleModeEnabled();
    }

    public Size getSurfaceSize() {
        verifyApplicationThread();
        return super.getSurfaceSize();
    }

    public long getTotalBufferedDuration() {
        verifyApplicationThread();
        return super.getTotalBufferedDuration();
    }

    public TrackSelectionParameters getTrackSelectionParameters() {
        verifyApplicationThread();
        return super.getTrackSelectionParameters();
    }

    public VideoSize getVideoSize() {
        verifyApplicationThread();
        return super.getVideoSize();
    }

    public float getVolume() {
        verifyApplicationThread();
        return super.getVolume();
    }

    public float getVolumeWithCommandCheck() {
        if (isCommandAvailable(22)) {
            return getVolume();
        }
        return 1.0f;
    }

    public boolean hasNextMediaItem() {
        verifyApplicationThread();
        return super.hasNextMediaItem();
    }

    public boolean hasPreviousMediaItem() {
        verifyApplicationThread();
        return super.hasPreviousMediaItem();
    }

    @Deprecated
    public void increaseDeviceVolume() {
        verifyApplicationThread();
        super.increaseDeviceVolume();
    }

    public boolean isCommandAvailable(int i2) {
        verifyApplicationThread();
        return super.isCommandAvailable(i2);
    }

    public boolean isCurrentMediaItemDynamic() {
        verifyApplicationThread();
        return super.isCurrentMediaItemDynamic();
    }

    public boolean isCurrentMediaItemLive() {
        verifyApplicationThread();
        return super.isCurrentMediaItemLive();
    }

    public boolean isCurrentMediaItemLiveWithCommandCheck() {
        return isCommandAvailable(16) && isCurrentMediaItemLive();
    }

    public boolean isCurrentMediaItemSeekable() {
        verifyApplicationThread();
        return super.isCurrentMediaItemSeekable();
    }

    public boolean isDeviceMuted() {
        verifyApplicationThread();
        return super.isDeviceMuted();
    }

    public boolean isDeviceMutedWithCommandCheck() {
        return isCommandAvailable(23) && isDeviceMuted();
    }

    public boolean isLoading() {
        verifyApplicationThread();
        return super.isLoading();
    }

    public boolean isPlaying() {
        verifyApplicationThread();
        return super.isPlaying();
    }

    public boolean isPlayingAd() {
        verifyApplicationThread();
        return super.isPlayingAd();
    }

    public void moveMediaItem(int i2, int i3) {
        verifyApplicationThread();
        super.moveMediaItem(i2, i3);
    }

    public void moveMediaItems(int i2, int i3, int i4) {
        verifyApplicationThread();
        super.moveMediaItems(i2, i3, i4);
    }

    public void pause() {
        verifyApplicationThread();
        super.pause();
    }

    public void play() {
        verifyApplicationThread();
        super.play();
    }

    public void playIfCommandAvailable() {
        if (isCommandAvailable(1)) {
            play();
        }
    }

    public void prepare() {
        verifyApplicationThread();
        super.prepare();
    }

    public void prepareIfCommandAvailable() {
        if (isCommandAvailable(2)) {
            prepare();
        }
    }

    public void release() {
        verifyApplicationThread();
        super.release();
    }

    public void removeListener(Player.Listener listener) {
        verifyApplicationThread();
        super.removeListener(listener);
    }

    public void removeMediaItem(int i2) {
        verifyApplicationThread();
        super.removeMediaItem(i2);
    }

    public void removeMediaItems(int i2, int i3) {
        verifyApplicationThread();
        super.removeMediaItems(i2, i3);
    }

    public void replaceMediaItem(int i2, MediaItem mediaItem) {
        verifyApplicationThread();
        super.replaceMediaItem(i2, mediaItem);
    }

    public void replaceMediaItems(int i2, int i3, List<MediaItem> list) {
        verifyApplicationThread();
        super.replaceMediaItems(i2, i3, list);
    }

    public void seekBack() {
        verifyApplicationThread();
        super.seekBack();
    }

    public void seekForward() {
        verifyApplicationThread();
        super.seekForward();
    }

    public void seekTo(long j2) {
        verifyApplicationThread();
        super.seekTo(j2);
    }

    public void seekToDefaultPosition(int i2) {
        verifyApplicationThread();
        super.seekToDefaultPosition(i2);
    }

    public void seekToDefaultPositionIfCommandAvailable() {
        if (isCommandAvailable(4)) {
            seekToDefaultPosition();
        }
    }

    public void seekToNext() {
        verifyApplicationThread();
        super.seekToNext();
    }

    public void seekToNextMediaItem() {
        verifyApplicationThread();
        super.seekToNextMediaItem();
    }

    public void seekToPrevious() {
        verifyApplicationThread();
        super.seekToPrevious();
    }

    public void seekToPreviousMediaItem() {
        verifyApplicationThread();
        super.seekToPreviousMediaItem();
    }

    @Deprecated
    public void setDeviceMuted(boolean z2) {
        verifyApplicationThread();
        super.setDeviceMuted(z2);
    }

    @Deprecated
    public void setDeviceVolume(int i2) {
        verifyApplicationThread();
        super.setDeviceVolume(i2);
    }

    public void setMediaItem(MediaItem mediaItem) {
        verifyApplicationThread();
        super.setMediaItem(mediaItem);
    }

    public void setMediaItems(List<MediaItem> list) {
        verifyApplicationThread();
        super.setMediaItems(list);
    }

    public void setPlayWhenReady(boolean z2) {
        verifyApplicationThread();
        super.setPlayWhenReady(z2);
    }

    public void setPlaybackParameters(PlaybackParameters playbackParameters) {
        verifyApplicationThread();
        super.setPlaybackParameters(playbackParameters);
    }

    public void setPlaybackSpeed(float f2) {
        verifyApplicationThread();
        super.setPlaybackSpeed(f2);
    }

    public void setPlaylistMetadata(MediaMetadata mediaMetadata) {
        verifyApplicationThread();
        super.setPlaylistMetadata(mediaMetadata);
    }

    public void setRepeatMode(int i2) {
        verifyApplicationThread();
        super.setRepeatMode(i2);
    }

    public void setShuffleModeEnabled(boolean z2) {
        verifyApplicationThread();
        super.setShuffleModeEnabled(z2);
    }

    public void setTrackSelectionParameters(TrackSelectionParameters trackSelectionParameters) {
        verifyApplicationThread();
        super.setTrackSelectionParameters(trackSelectionParameters);
    }

    public void setVideoSurface(@Nullable Surface surface) {
        verifyApplicationThread();
        super.setVideoSurface(surface);
    }

    public void setVideoSurfaceHolder(@Nullable SurfaceHolder surfaceHolder) {
        verifyApplicationThread();
        super.setVideoSurfaceHolder(surfaceHolder);
    }

    public void setVideoSurfaceView(@Nullable SurfaceView surfaceView) {
        verifyApplicationThread();
        super.setVideoSurfaceView(surfaceView);
    }

    public void setVideoTextureView(@Nullable TextureView textureView) {
        verifyApplicationThread();
        super.setVideoTextureView(textureView);
    }

    public void setVolume(float f2) {
        verifyApplicationThread();
        super.setVolume(f2);
    }

    public void stop() {
        verifyApplicationThread();
        super.stop();
    }

    public void addMediaItem(int i2, MediaItem mediaItem) {
        verifyApplicationThread();
        super.addMediaItem(i2, mediaItem);
    }

    public void addMediaItems(int i2, List<MediaItem> list) {
        verifyApplicationThread();
        super.addMediaItems(i2, list);
    }

    public void clearVideoSurface(@Nullable Surface surface) {
        verifyApplicationThread();
        super.clearVideoSurface(surface);
    }

    public void decreaseDeviceVolume(int i2) {
        verifyApplicationThread();
        super.decreaseDeviceVolume(i2);
    }

    public void increaseDeviceVolume(int i2) {
        verifyApplicationThread();
        super.increaseDeviceVolume(i2);
    }

    public void seekTo(int i2, long j2) {
        verifyApplicationThread();
        super.seekTo(i2, j2);
    }

    public void seekToDefaultPosition() {
        verifyApplicationThread();
        super.seekToDefaultPosition();
    }

    public void setDeviceMuted(boolean z2, int i2) {
        verifyApplicationThread();
        super.setDeviceMuted(z2, i2);
    }

    public void setDeviceVolume(int i2, int i3) {
        verifyApplicationThread();
        super.setDeviceVolume(i2, i3);
    }

    public void setMediaItem(MediaItem mediaItem, long j2) {
        verifyApplicationThread();
        super.setMediaItem(mediaItem, j2);
    }

    public void setMediaItems(List<MediaItem> list, boolean z2) {
        verifyApplicationThread();
        super.setMediaItems(list, z2);
    }

    public void setMediaItem(MediaItem mediaItem, boolean z2) {
        verifyApplicationThread();
        super.setMediaItem(mediaItem, z2);
    }

    public void setMediaItems(List<MediaItem> list, int i2, long j2) {
        verifyApplicationThread();
        super.setMediaItems(list, i2, j2);
    }
}