package tv.danmaku.ijk.media.player.ui;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.SurfaceTexture;
import android.graphics.Typeface;
import android.graphics.drawable.Drawable;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Handler;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.widget.FrameLayout;
import android.widget.ImageView;
import androidx.annotation.NonNull;
import androidx.annotation.OptIn;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.rtsp.RtspHeaders;
import androidx.media3.ui.CaptionStyleCompat;
import androidx.media3.ui.SubtitleView;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import tv.danmaku.ijk.media.player.IMediaPlayer;
import tv.danmaku.ijk.media.player.IjkMediaPlayer;
import tv.danmaku.ijk.media.player.IjkTimedText;
import tv.danmaku.ijk.media.player.MediaSource;
import tv.danmaku.ijk.media.player.R;
import tv.danmaku.ijk.media.player.RandomMediaDataSource;
import tv.danmaku.ijk.media.player.misc.ITrackInfo;
import tv.danmaku.ijk.media.player.ui.IRenderView;
import tv.danmaku.ijk.media.player.ui.subtitleconverter.SubtitleParser;

/* JADX INFO: loaded from: classes3.dex */
public class IjkVideoView extends BasePlayerView implements IRenderView.IRenderCallback {
    private static final int PLAYER_EXO = 2;
    private static final int PLAYER_EXO_PLAY_BACK = 4;
    private static final int PLAYER_IJK = 1;
    private static final int PLAYER_NONE = -1;
    private static final ExecutorService RELEASE_EXECUTOR = Executors.newSingleThreadExecutor(new b());
    private static final int RENDER_SURFACE_VIEW = 0;
    private static final int RENDER_TEXTURE_VIEW = 1;
    public static final int STATE_ENDED = 5;
    public static final int STATE_ERROR = -1;
    public static final int STATE_IDLE = 0;
    public static final int STATE_PAUSED = 4;
    public static final int STATE_PLAYING = 3;
    public static final int STATE_PREPARED = 2;
    public static final int STATE_PREPARING = 1;
    private static final int codec = 2;
    private static final int format = 1;
    private static final int player = 4;
    private final ImageView mArtworkView;
    private final AudioManager mAudioManager;
    private final FrameLayout mContentFrame;
    private int mCurrentAspectRatio;
    private int mCurrentBufferPercentage;
    private long mCurrentBufferPosition;
    private int mCurrentDecode;
    private int mCurrentPlayer;
    private int mCurrentRender;
    private float mCurrentSpeed;
    private int mCurrentState;
    private IMediaPlayer.Listener mListener;
    private IMediaPlayer mPlayer;
    private IRenderView mRenderView;
    private int mStartPosition;
    private IRenderView.ISurfaceHolder mSurfaceHolder;
    private int mTargetState;
    private int mVideoHeight;
    private int mVideoWidth;
    private int subtitleTextSize;
    private int subtitleTextUnit;

    @SuppressLint({"UnsafeOptInUsageError"})
    private SubtitleView subtitleView;
    SurfaceTexture surfaceTexture;
    private Timer timer;
    long totalByte;

    public static class MediaRequest {
        private final Map<String, String> headers;
        private final Uri uri;

        public /* synthetic */ MediaRequest(Uri uri, HashMap map) {
            this(uri, (Map<String, String>) map);
        }

        private MediaRequest(Uri uri, Map<String, String> map) {
            this.uri = uri;
            this.headers = map;
        }
    }

    public IjkVideoView(Context context) {
        this(context, null);
    }

    @OptIn(markerClass = {UnstableApi.class})
    private void applySubtitleTextSize() {
        SubtitleView subtitleView = this.subtitleView;
        if (subtitleView == null) {
            return;
        }
        subtitleView.setFixedTextSize(this.subtitleTextUnit, this.subtitleTextSize);
    }

    private void bindSurfaceHolder(IMediaPlayer iMediaPlayer, IRenderView.ISurfaceHolder iSurfaceHolder) {
        if (iMediaPlayer == null || iSurfaceHolder == null) {
            return;
        }
        iSurfaceHolder.bindToMediaPlayer(iMediaPlayer);
    }

    private MediaRequest buildMediaRequest(Uri uri, Map<String, String> map) {
        HashMap map2 = map == null ? new HashMap() : new HashMap(map);
        String string = uri == null ? "" : uri.toString();
        int iIndexOf = string.indexOf(124);
        if (iIndexOf < 0) {
            return new MediaRequest(uri, map2);
        }
        String strSubstring = string.substring(0, iIndexOf);
        for (String str : string.substring(iIndexOf + 1).split("&")) {
            int iIndexOf2 = str.indexOf(61);
            if (iIndexOf2 > 0) {
                String strNormalizeHeaderName = normalizeHeaderName(Uri.decode(str.substring(0, iIndexOf2).trim()));
                String strDecode = Uri.decode(str.substring(iIndexOf2 + 1).trim());
                if (!TextUtils.isEmpty(strNormalizeHeaderName) && !TextUtils.isEmpty(strDecode)) {
                    map2.put(strNormalizeHeaderName, strDecode);
                }
            }
        }
        return new MediaRequest(Uri.parse(strSubstring), map2);
    }

    private void cancelTimer() {
        Timer timer = this.timer;
        if (timer != null) {
            timer.cancel();
            this.timer = null;
        }
    }

    private boolean isInPlaybackState() {
        int i10;
        return (this.mPlayer == null || (i10 = this.mCurrentState) == -1 || i10 == 0 || i10 == 1) ? false : true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$release$1(IMediaPlayer iMediaPlayer) {
        try {
            iMediaPlayer.release();
        } catch (Throwable th) {
            IjkPlayerRuntime.logError("release player error: " + th.getMessage());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ Thread lambda$static$0(Runnable runnable) {
        Thread thread = new Thread(runnable, "ijk-release");
        thread.setDaemon(true);
        return thread;
    }

    private String normalizeHeaderName(String str) {
        return TextUtils.isEmpty(str) ? "" : ("referer".equalsIgnoreCase(str) || "referrer".equalsIgnoreCase(str)) ? "Referer" : "user-agent".equalsIgnoreCase(str) ? RtspHeaders.USER_AGENT : "cookie".equalsIgnoreCase(str) ? "Cookie" : str;
    }

    private void openVideo(Uri uri, Map<String, String> map, int i10, String str) {
        try {
            this.mPlayer.reset();
            setOptions(i10, false, false, str, CacheManager.getInstance().getCacheKey(uri.toString()));
            setRenderView(this.mCurrentRender);
            this.mAudioManager.requestAudioFocus(null, 3, 1);
            this.mPlayer.setDataSource(getContext(), uri, map);
            setTimer();
            this.mPlayer.setAudioStreamType(3);
            this.mPlayer.setScreenOnWhilePlaying(true);
            this.mPlayer.prepareAsync();
            this.mCurrentState = 1;
        } catch (Throwable th) {
            onError(this.mPlayer, 1, 0, th.getMessage());
            this.mCurrentState = -1;
            this.mTargetState = -1;
        }
    }

    private void openVideoFileStart(File file, String str, int i10, String str2) {
        try {
            this.mPlayer.reset();
            setOptions(0, false, false, str2, null);
            setRenderView(this.mCurrentRender);
            this.mAudioManager.requestAudioFocus(null, 3, 1);
            if (TextUtils.isEmpty(str)) {
                this.mPlayer.setDataSource(file.getAbsolutePath());
            } else {
                this.mPlayer.setDataSource(new RandomMediaDataSource(file, str));
            }
            this.mPlayer.setAudioStreamType(3);
            this.mPlayer.setScreenOnWhilePlaying(true);
            this.mPlayer.prepareAsync();
            this.mCurrentState = 1;
        } catch (Throwable th) {
            onError(this.mPlayer, 1, 0, th.getMessage());
            this.mCurrentState = -1;
            this.mTargetState = -1;
        }
    }

    private void openVideoStart(Uri uri, Map<String, String> map, int i10, boolean z10, String str) {
        try {
            this.mPlayer.reset();
            setOptions(i10, true, z10, str, CacheManager.getInstance().getCacheKey(uri.toString()));
            setRenderView(this.mCurrentRender);
            this.mAudioManager.requestAudioFocus(null, 3, 1);
            this.mPlayer.setDataSource(getContext(), uri, map);
            this.mPlayer.setAudioStreamType(3);
            this.mPlayer.setScreenOnWhilePlaying(true);
            this.mPlayer.prepareAsync();
            this.mCurrentState = 1;
        } catch (Throwable th) {
            onError(this.mPlayer, 1, 0, th.getMessage());
            this.mCurrentState = -1;
            this.mTargetState = -1;
        }
    }

    private void removeRenderView() {
        IRenderView iRenderView = this.mRenderView;
        if (iRenderView == null) {
            return;
        }
        this.mContentFrame.removeView(iRenderView.getView());
        int i10 = this.mCurrentPlayer;
        if (i10 == 2 || i10 == 4) {
            this.mContentFrame.removeView(this.subtitleView);
        }
        this.mRenderView.removeRenderCallback(this);
        this.mRenderView = null;
        this.mSurfaceHolder = null;
    }

    private void reset() {
        removeRenderView();
        this.mTargetState = 0;
        this.mCurrentState = 0;
        this.mCurrentBufferPosition = 0L;
        this.mCurrentBufferPercentage = 0;
        this.mAudioManager.abandonAudioFocus(null);
    }

    private void setOptions(int i10, boolean z10, boolean z11, String str, String str2) {
        this.mPlayer.setOption(2, "skip_loop_filter", 48L);
        this.mPlayer.setOption(1, "dns_cache_clear", 0L);
        this.mPlayer.setOption(1, "dns_cache_timeout", -1L);
        this.mPlayer.setOption(1, "fflags", "fastseek");
        this.mPlayer.setOption(4, "enable-accurate-seek", 1L);
        this.mPlayer.setOption(4, "framedrop", 5L);
        this.mPlayer.setOption(4, "packet-buffering", 1L);
        this.mPlayer.setOption(4, "find_stream_info", 1L);
        this.mPlayer.setOption(4, "mediacodec", this.mCurrentDecode);
        this.mPlayer.setOption(4, "mediacodec-hevc", this.mCurrentDecode);
        this.mPlayer.setOption(4, "mediacodec-all-videos", this.mCurrentDecode);
        this.mPlayer.setOption(4, "mediacodec-auto-rotate", this.mCurrentDecode);
        this.mPlayer.setOption(4, "mediacodec-handle-resolution-change", this.mCurrentDecode);
        this.mPlayer.setOption(4, "opensles", 0L);
        this.mPlayer.setOption(4, "overlay-format", 842225234L);
        this.mPlayer.setOption(4, "reconnect", 1L);
        this.mPlayer.setOption(4, "soundtouch", 1L);
        this.mPlayer.setOption(4, "audio_disable", 1L);
        this.mPlayer.setOption(4, "start-on-prepared", z10 ? 1L : 0L);
        this.mPlayer.setOption(4, "subtitle", 1L);
        this.mPlayer.setOption(4, "audio-language", str);
        this.mPlayer.setOption(1, "infbuf", 0L);
        this.mPlayer.setOption(1, "rtsp_transport", "tcp");
        this.mPlayer.setOption(1, "rtsp_flags", "prefer_tcp");
        this.mPlayer.setOption(1, "timeout", 300000000L);
        this.mPlayer.setOption(1, "flush_packets", 1L);
        this.mPlayer.setOption(4, "sync-av-start", 0L);
        if (i10 > 0) {
            this.mPlayer.setOption(4, "seek-at-start", i10);
        }
        if (z11) {
            this.mPlayer.setOption(1, "http-detect-range-support", 0L);
            this.mPlayer.setOption(1, "max_cached_duration", 60000L);
            this.mPlayer.setOption(4, "framedrop", 5L);
            this.mPlayer.setOption(4, "packet-buffering", 1L);
            this.mPlayer.setOption(1, "flush_packets", 1L);
            return;
        }
        this.mPlayer.setOption(1, "http-detect-range-support", 1L);
        this.mPlayer.setOption(1, "analyzemaxduration", 100L);
        this.mPlayer.setOption(1, "probesize", 1024L);
        this.mPlayer.setOption(1, "fflags", "fastseek");
        this.mPlayer.setOption(4, "framedrop", 5L);
        if (str2 == null || !CacheManager.getInstance().isMemoryEnough()) {
            this.mPlayer.setOption(4, "max-buffer-size", 20971520L);
            return;
        }
        try {
            File file = new File(CacheManager.getInstance().cachePath + str2 + ".temp");
            File file2 = new File(CacheManager.getInstance().cachePath + str2 + ".map");
            this.mPlayer.setOption(1, "cache_file_path", file.getAbsolutePath());
            this.mPlayer.setOption(1, "cache_map_path", file2.getAbsolutePath());
            this.mPlayer.setOption(1, "cache_max_capacity", 31457280L);
            this.mPlayer.setOption(1, "parse_cache_map", 1L);
            this.mPlayer.setOption(1, "auto_save_map", 1L);
        } catch (Exception e10) {
            IjkPlayerRuntime.logError("set cache option error: " + e10.getMessage());
        }
    }

    private void setRenderView(int i10) {
        if (this.mRenderView != null) {
            bindSurfaceHolder(this.mPlayer, this.mSurfaceHolder);
            return;
        }
        if (i10 == 0) {
            setRenderView(new SurfaceRenderView(getContext()));
        } else {
            if (i10 != 1) {
                return;
            }
            if (this.surfaceTexture == null) {
                this.surfaceTexture = new SurfaceTexture(0);
            }
            setRenderView(new TextureRenderView(getContext(), this.surfaceTexture));
        }
    }

    private void setTimer() {
        this.totalByte = 0L;
        if (this.timer != null) {
            cancelTimer();
        }
        Timer timer = new Timer();
        this.timer = timer;
        timer.schedule(new TimerTask() { // from class: tv.danmaku.ijk.media.player.ui.IjkVideoView.1
            @Override // java.util.TimerTask, java.lang.Runnable
            public void run() {
                IjkVideoView ijkVideoView = IjkVideoView.this;
                ijkVideoView.totalByte = ijkVideoView.getTcpSpeed() + ijkVideoView.totalByte;
            }
        }, 0L, 1000L);
    }

    private void setVideoFileStart(File file, String str, int i10, String str2) {
        openVideoFileStart(file, str, i10, str2);
        requestLayout();
        invalidate();
    }

    private void setVideoURI(Uri uri, Map<String, String> map, int i10, String str) {
        openVideo(uri, map, i10, str);
        requestLayout();
        invalidate();
    }

    private void setVideoURIStart(Uri uri, Map<String, String> map, int i10, boolean z10, String str) {
        MediaRequest mediaRequestBuildMediaRequest = buildMediaRequest(uri, map);
        openVideoStart(mediaRequestBuildMediaRequest.uri, mediaRequestBuildMediaRequest.headers, i10, z10, str);
        requestLayout();
        invalidate();
    }

    private void updateForCurrentTrackSelections() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null || iMediaPlayer.getTrackInfo() == null || this.mPlayer.getTrackInfo().isEmpty()) {
            return;
        }
        int selectedTrack = getSelectedTrack(2);
        boolean zHaveTrack = haveTrack(2);
        if (selectedTrack < 0 && !zHaveTrack) {
            removeRenderView();
        } else if (this.mRenderView == null) {
            setRenderView(this.mCurrentRender);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void addListener(IMediaPlayer.Listener listener) {
        this.mListener = listener;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public boolean canPause() {
        return true;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public boolean canSeekBackward() {
        return true;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public boolean canSeekForward() {
        return true;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void closeSubtitleView() {
        if (isSubtitleViewAdded()) {
            this.subtitleView.setVisibility(8);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void decode(int i10) {
        this.mCurrentDecode = i10;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    @OptIn(markerClass = {UnstableApi.class})
    public void deselectTrack(int i10, int i11) {
        if (this.mPlayer == null || i11 < 0) {
            return;
        }
        int selectedTrack = getSelectedTrack(i10);
        List<ITrackInfo> trackInfo = getTrackInfo();
        for (int i12 = 0; i12 < trackInfo.size(); i12++) {
            if (trackInfo.get(i12).getTrackType() == i10 && i12 == i11 && selectedTrack == i11) {
                SubtitleView subtitleView = this.subtitleView;
                if (subtitleView != null) {
                    subtitleView.setCues(null);
                }
                this.mPlayer.deselectTrack(i11);
                updateForCurrentTrackSelections();
            }
        }
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public int getAudioSessionId() {
        return 0;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public int getBufferPercentage() {
        if (this.mPlayer != null) {
            return this.mCurrentBufferPercentage;
        }
        return 0;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public long getBufferedPosition() {
        int i10 = this.mCurrentPlayer;
        if (i10 == 2 || i10 == 4) {
            if (isInPlaybackState()) {
                return this.mPlayer.getBufferedPosition();
            }
            return 0L;
        }
        if (this.mPlayer != null) {
            return this.mCurrentBufferPosition;
        }
        return 0L;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public int getCurrentPosition() {
        if (isInPlaybackState()) {
            return (int) this.mPlayer.getCurrentPosition();
        }
        return 0;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public int getDuration() {
        if (isInPlaybackState()) {
            return (int) this.mPlayer.getDuration();
        }
        return -1;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public int getPlaybackState() {
        return this.mCurrentState;
    }

    public ITrackInfo getSelectVideoTrackInfo() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return null;
        }
        return iMediaPlayer.getSelectedVideoTrackInfo();
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public int getSelectedGroupTrack(int i10) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return -1;
        }
        return iMediaPlayer.getSelectedGroupTrack(i10);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public int getSelectedTrack(int i10) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return -1;
        }
        return iMediaPlayer.getSelectedTrack(i10);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public ITrackInfo getSelectedTrackInfo(int i10) {
        if (this.mPlayer == null) {
            return null;
        }
        int selectedTrack = getSelectedTrack(i10);
        List<ITrackInfo> trackInfo = getTrackInfo();
        for (int i11 = 0; i11 < trackInfo.size(); i11++) {
            ITrackInfo iTrackInfo = trackInfo.get(i11);
            if (iTrackInfo.getTrackType() == i10 && i11 == selectedTrack) {
                return iTrackInfo;
            }
        }
        return null;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public float getSpeed() {
        return isInPlaybackState() ? this.mPlayer.getSpeed() : this.mCurrentSpeed;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public long getTcpSpeed() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            return iMediaPlayer.getTcpSpeed();
        }
        return 0L;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public long getTotalByte() {
        return this.totalByte;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public List<ITrackInfo> getTrackInfo() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        return iMediaPlayer == null ? new ArrayList() : iMediaPlayer.getTrackInfo();
    }

    public long getVideoCachedBytes() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            return iMediaPlayer.getVideoCachedBytes();
        }
        return 0L;
    }

    public long getVideoCachedDuration() {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            return iMediaPlayer.getVideoCachedDuration();
        }
        return 0L;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public int getVideoHeight() {
        return this.mVideoHeight;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public int getVideoWidth() {
        return this.mVideoWidth;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public boolean haveTrack(int i10) {
        if (this.mPlayer == null) {
            return false;
        }
        Iterator<ITrackInfo> it = getTrackInfo().iterator();
        int i11 = 0;
        while (it.hasNext()) {
            if (it.next().getTrackType() == i10) {
                i11++;
            }
        }
        return i11 > 0;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public boolean isPlaying() {
        return isInPlaybackState() && this.mPlayer.isPlaying();
    }

    public boolean isSubtitleViewAdded() {
        SubtitleView subtitleView = this.subtitleView;
        return subtitleView != null && subtitleView.getParent() == this.mContentFrame;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onAudioTrackSelect(ITrackInfo iTrackInfo) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onAudioTrackSelect(iTrackInfo);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onBitrateChange(int i10, long j10, long j11) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onBitrateChange(i10, j10, j11);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onBufferingUpdate(IMediaPlayer iMediaPlayer, int i10) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onBufferingUpdate(iMediaPlayer, i10);
        this.mCurrentBufferPercentage = i10;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onCompletion(IMediaPlayer iMediaPlayer) {
        if (iMediaPlayer != this.mPlayer) {
            return;
        }
        this.mCurrentState = 5;
        this.mTargetState = 5;
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onCompletion(iMediaPlayer);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public boolean onError(IMediaPlayer iMediaPlayer, int i10, int i11, String str) {
        if (iMediaPlayer != this.mPlayer) {
            return false;
        }
        this.mCurrentState = -1;
        this.mTargetState = -1;
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return false;
        }
        return listener.onError(iMediaPlayer, i10, i11, str);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onInfo(IMediaPlayer iMediaPlayer, int i10, int i11) {
        IRenderView iRenderView;
        if (iMediaPlayer != this.mPlayer) {
            return;
        }
        if (i10 == 3 || i10 == 702) {
            this.mArtworkView.setVisibility(8);
            cancelTimer();
        }
        if (i10 == 10001 && (iRenderView = this.mRenderView) != null) {
            iRenderView.setVideoRotation(i11);
        }
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onInfo(iMediaPlayer, i10, i11);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onLoadedData(String str, long j10, int i10, int i11, int i12, String str2) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onLoadedData(str, j10, i10, i11, i12, str2);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onLog(IMediaPlayer iMediaPlayer, String str) {
        IMediaPlayer.Listener listener;
        if (iMediaPlayer == this.mPlayer && (listener = this.mListener) != null) {
            listener.onLog(iMediaPlayer, str);
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onPrepared(IMediaPlayer iMediaPlayer) {
        if (iMediaPlayer != this.mPlayer) {
            return;
        }
        this.mCurrentState = 3;
        updateForCurrentTrackSelections();
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onPrepared(iMediaPlayer);
        this.mVideoWidth = iMediaPlayer.getVideoWidth();
        this.mVideoHeight = iMediaPlayer.getVideoHeight();
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onSubtitleTrackSelect(ITrackInfo iTrackInfo) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onSubtitleTrackSelect(iTrackInfo);
    }

    @Override // tv.danmaku.ijk.media.player.ui.IRenderView.IRenderCallback
    public void onSurfaceChanged(@NonNull IRenderView.ISurfaceHolder iSurfaceHolder, int i10, int i11, int i12) {
        boolean z10 = false;
        boolean z11 = this.mTargetState == 3;
        if (!this.mRenderView.shouldWaitForResize() || (this.mVideoWidth == i11 && this.mVideoHeight == i12)) {
            z10 = true;
        }
        if (this.mPlayer != null && z11 && z10) {
            start();
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.IRenderView.IRenderCallback
    public void onSurfaceCreated(@NonNull IRenderView.ISurfaceHolder iSurfaceHolder, int i10, int i11) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            this.mSurfaceHolder = iSurfaceHolder;
            bindSurfaceHolder(iMediaPlayer, iSurfaceHolder);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.IRenderView.IRenderCallback
    public void onSurfaceDestroyed(@NonNull IRenderView.ISurfaceHolder iSurfaceHolder) {
        IRenderView renderView = iSurfaceHolder.getRenderView();
        IRenderView iRenderView = this.mRenderView;
        if (renderView == iRenderView || iRenderView == null) {
            this.mSurfaceHolder = null;
            IMediaPlayer iMediaPlayer = this.mPlayer;
            if (iMediaPlayer != null) {
                iMediaPlayer.setDisplay(null);
            }
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    @OptIn(markerClass = {UnstableApi.class})
    public void onTimedText(IMediaPlayer iMediaPlayer, IjkTimedText ijkTimedText) {
        if (ijkTimedText != null) {
            this.subtitleView.setCues(SubtitleParser.parse(ijkTimedText.getText()));
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onVideoSizeChanged(IMediaPlayer iMediaPlayer, int i10, int i11, int i12, int i13) {
        IRenderView iRenderView;
        this.mVideoWidth = iMediaPlayer.getVideoWidth();
        int videoHeight = iMediaPlayer.getVideoHeight();
        this.mVideoHeight = videoHeight;
        int i14 = this.mVideoWidth;
        if (i14 == 0 || videoHeight == 0 || (iRenderView = this.mRenderView) == null) {
            return;
        }
        iRenderView.setVideoSize(i14, videoHeight);
        this.mRenderView.setVideoSampleAspectRatio(i12, i13);
        requestLayout();
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onVideoTrackSelect(ITrackInfo iTrackInfo) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onVideoTrackSelect(iTrackInfo);
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public void pause() {
        if (isInPlaybackState() && this.mPlayer.isPlaying()) {
            this.mPlayer.pause();
            this.mCurrentState = 4;
        }
        this.mTargetState = 4;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void release() {
        cancelTimer();
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return;
        }
        this.mCurrentPlayer = -1;
        this.mPlayer = null;
        reset();
        RELEASE_EXECUTOR.execute(new a(iMediaPlayer, 2));
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void removeListener() {
        this.mListener = null;
    }

    public IjkVideoView render(int i10) {
        setRender(i10);
        return this;
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public void seekTo(int i10) {
        if (isInPlaybackState()) {
            onInfo(this.mPlayer, IMediaPlayer.MEDIA_INFO_BUFFERING_START, 0);
            this.mPlayer.seekTo(i10);
            this.mStartPosition = 0;
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void selectGroupTrack(int i10, int i11, int i12) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return;
        }
        iMediaPlayer.selectTrack(i10, i11, i12);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void selectTrack(int i10, int i11, boolean z10) {
        if (this.mPlayer == null || i11 < 0) {
            return;
        }
        int selectedTrack = getSelectedTrack(i10);
        long currentPosition = getCurrentPosition();
        List<ITrackInfo> trackInfo = getTrackInfo();
        for (int i12 = 0; i12 < trackInfo.size(); i12++) {
            if (trackInfo.get(i12).getTrackType() == i10 && i12 == i11 && selectedTrack != i11) {
                this.mPlayer.selectTrack(i12);
                updateForCurrentTrackSelections();
                if (z10) {
                    this.mPlayer.seekTo(currentPosition);
                }
            }
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setDrawableArtwork(Drawable drawable) {
        if (drawable == null) {
            return;
        }
        int intrinsicWidth = drawable.getIntrinsicWidth();
        int intrinsicHeight = drawable.getIntrinsicHeight();
        if (intrinsicWidth == 0 || intrinsicHeight == 0) {
            return;
        }
        if (getPlaybackState() >= 2) {
            this.mArtworkView.setVisibility(8);
        } else {
            this.mArtworkView.setImageDrawable(drawable);
            this.mArtworkView.setVisibility(0);
        }
    }

    public void setExoPlayer(SurfaceTexture surfaceTexture) {
        this.mCurrentPlayer = 2;
        this.mCurrentRender = 1;
        this.surfaceTexture = surfaceTexture;
        this.mPlayer = new IjkExo2MediaPlayer(getContext(), null).setListener(this);
    }

    public void setIjkPlayer(SurfaceTexture surfaceTexture) {
        this.mCurrentPlayer = 1;
        this.mCurrentRender = 1;
        this.surfaceTexture = surfaceTexture;
        this.mPlayer = new IjkMediaPlayer().setListener(this);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    @OptIn(markerClass = {UnstableApi.class})
    public void setInnerSubtitleView(int i10, int i11, boolean z10) {
        if (this.mPlayer == null || i11 < 0 || !haveTrack(3)) {
            return;
        }
        if (!isSubtitleViewAdded()) {
            this.mContentFrame.addView(this.subtitleView, new FrameLayout.LayoutParams(-1, -1, 17));
        }
        applySubtitleTextSize();
        this.subtitleView.setVisibility(0);
        this.subtitleView.setStyle(new CaptionStyleCompat(-1, 0, 0, 0, -16777216, Typeface.DEFAULT));
        selectTrack(3, i11, z10);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setLooping(boolean z10) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            iMediaPlayer.setLooping(z10);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setMediaSource(String str, int i10, String str2) {
        setVideoURI(Uri.parse(str), new HashMap(), i10, str2);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setMediaSourceLive(MediaSource mediaSource) {
        setVideoURIStart(mediaSource.getUri(), mediaSource.getHeaders(), 0, true, null);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setMediaSourceStart(String str, int i10, String str2) {
        setVideoURIStart(Uri.parse(str), new HashMap(), i10, false, str2);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setPlayer(int i10) {
        if (this.mCurrentPlayer == i10) {
            return;
        }
        if (this.mPlayer != null) {
            release();
        }
        this.mCurrentPlayer = i10;
        if (i10 == 1) {
            this.mPlayer = new IjkMediaPlayer().setListener(this);
            this.subtitleView.setVisibility(8);
        } else if (i10 == 2) {
            this.subtitleView.setVisibility(0);
            this.mPlayer = new IjkExo2MediaPlayer(getContext(), this.subtitleView).setListener(this);
        } else {
            if (i10 != 4) {
                return;
            }
            this.mPlayer = new ExoPlaybackMediaPlayer(getContext()).setListener(this);
        }
    }

    public void setRender(int i10) {
        this.mCurrentRender = i10;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setResizeMode(int i10) {
        this.mCurrentAspectRatio = i10;
        IRenderView iRenderView = this.mRenderView;
        if (iRenderView != null) {
            iRenderView.setAspectRatio(i10);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setSpeed(float f10) {
        this.mCurrentSpeed = f10;
        if (isInPlaybackState()) {
            this.mPlayer.setSpeed(f10);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    @OptIn(markerClass = {UnstableApi.class})
    public void setSubtitleBgEnable(boolean z10) {
        if (isSubtitleViewAdded()) {
            this.subtitleView.setStyle(new CaptionStyleCompat(-1, z10 ? -16777216 : 0, 0, 0, -16777216, Typeface.DEFAULT));
        }
    }

    @SuppressLint({"UnsafeOptInUsageError"})
    public void setSubtitleEnable() {
        if (IjkPlayerRuntime.isLiveSubtitleEnabled()) {
            this.subtitleView.setVisibility(0);
        } else {
            this.subtitleView.setVisibility(8);
        }
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    @OptIn(markerClass = {UnstableApi.class})
    public void setSubtitleSize(int i10) {
        this.subtitleTextUnit = 2;
        this.subtitleTextSize = i10;
        applySubtitleTextSize();
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    @OptIn(markerClass = {UnstableApi.class})
    public void setSubtitleSizePx(int i10) {
        this.subtitleTextUnit = 0;
        this.subtitleTextSize = i10;
        applySubtitleTextSize();
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setVolume(float f10, float f11) {
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer != null) {
            iMediaPlayer.setVolume(f10, f11);
        }
    }

    public void setWakeMode(int i10) {
        this.mPlayer.setWakeMode(getContext(), i10);
    }

    @Override // android.widget.MediaController.MediaPlayerControl
    public void start() {
        if (isInPlaybackState()) {
            this.mPlayer.start();
            this.mCurrentState = 3;
        }
        this.mTargetState = 3;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void stop() {
        cancelTimer();
        IMediaPlayer iMediaPlayer = this.mPlayer;
        if (iMediaPlayer == null) {
            return;
        }
        iMediaPlayer.stop();
        reset();
    }

    public IjkVideoView(Context context, AttributeSet attributeSet) {
        this(context, attributeSet, 0);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer.Listener
    public void onBufferingUpdate(IMediaPlayer iMediaPlayer, long j10) {
        IMediaPlayer.Listener listener = this.mListener;
        if (listener == null) {
            return;
        }
        listener.onBufferingUpdate(iMediaPlayer, j10);
        this.mCurrentBufferPosition = j10;
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void setMediaSourceStart(File file, String str, int i10, String str2) {
        setVideoFileStart(file, str, i10, str2);
    }

    @SuppressLint({"UnsafeOptInUsageError"})
    public IjkVideoView(Context context, AttributeSet attributeSet, int i10) {
        super(context, attributeSet, i10);
        this.subtitleTextUnit = 2;
        this.subtitleTextSize = 50;
        this.totalByte = 0L;
        LayoutInflater.from(context).inflate(R.layout.ijk_player_view, this);
        this.mAudioManager = (AudioManager) getContext().getSystemService("audio");
        this.mContentFrame = (FrameLayout) findViewById(R.id.ijk_content_frame);
        this.mArtworkView = (ImageView) findViewById(R.id.ijk_artwork);
        this.mCurrentPlayer = -1;
        this.mCurrentState = 0;
        this.mTargetState = 0;
        this.mCurrentSpeed = 1.0f;
        this.subtitleView = new SubtitleView(context);
        this.subtitleTextSize = IjkPlayerRuntime.getSubtitleSize();
        applySubtitleTextSize();
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void start(int i10) {
        this.mPlayer.seekTo(i10);
        new Handler().postDelayed(new a(this, 3), 500L);
    }

    @Override // tv.danmaku.ijk.media.player.ui.BasePlayerView
    public void seekTo(long j10) {
        int i10 = (int) j10;
        this.mStartPosition = i10;
        seekTo(i10);
    }

    @SuppressLint({"UnsafeOptInUsageError"})
    private void setRenderView(IRenderView iRenderView) {
        this.mRenderView = iRenderView;
        setResizeMode(this.mCurrentAspectRatio);
        this.mContentFrame.addView(this.mRenderView.getView(), 0, new FrameLayout.LayoutParams(-1, -1, 17));
        int i10 = this.mCurrentPlayer;
        if (i10 == 2 || i10 == 4) {
            this.mContentFrame.addView(this.subtitleView, 1, new FrameLayout.LayoutParams(-1, -1, 17));
            applySubtitleTextSize();
            setSubtitleEnable();
        }
        this.mRenderView.addRenderCallback(this);
    }
}