package com.ifpdos.player;

import Y0.b;
import android.content.Context;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.Parcel;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import com.ifpdos.player.base.MediaListenerDispatcher;
import com.ifpdos.player.base.MediaMetaDataInfo;
import com.ifpdos.player.base.OnMediaPlayerListener;
import com.ifpdos.player.base.PlatformUtils;
import java.io.IOException;
import java.util.concurrent.ConcurrentLinkedQueue;
import okhttp3.HttpUrl;

/* JADX INFO: loaded from: classes.dex */
public final class AndroidMediaPlayer extends BasePlayer {
    private static final int CMD_GET_VIDEO_INFO = 5033;
    private static final int CMD_INVOKE_BASE = 5000;
    public static final Companion Companion = new Companion(null);
    private static final int HEVC_CODE = 36;
    public static final int MEDIA_INFO_AUDIO_UNSUPPORT = 1002;
    public static final int MEDIA_INFO_VIDEO_UNSUPPORT = 1003;
    private static final int MSG_PAUSE = 4;
    private static final int MSG_PREPARE = 2;
    private static final int MSG_RELEASE = 7;
    private static final int MSG_RESET = 6;
    private static final int MSG_SET_DATASOURCE = 0;
    private static final int MSG_SET_DATASOURCE_RESULT_DETACH = 1;
    private static final int MSG_START = 3;
    private static final int MSG_STOP = 5;
    private static final String TAG = "AndroidMediaPlayer";
    private final Context context;
    private boolean isOnError;
    private boolean isPrepared;
    private boolean isReseted;
    private final ConcurrentLinkedQueue<Runnable> mAfterReleaseTasks;
    private final AndroidMediaPlayer$mHandler$1 mHandler;
    private final HandlerThread mHandlerThread;
    private final MediaListenerDispatcher mListenerDispatcher;
    private final AndroidMediaPlayer$mMainHandler$1 mMainHandler;
    private final MediaPlayer mMediaPlayer;

    public static final class Companion {
        public /* synthetic */ Companion(kotlin.jvm.internal.g gVar) {
            this();
        }

        private Companion() {
        }
    }

    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
    /* JADX WARN: Type inference failed for: r1v2, types: [com.ifpdos.player.AndroidMediaPlayer$mHandler$1] */
    /* JADX WARN: Type inference failed for: r1v3, types: [com.ifpdos.player.AndroidMediaPlayer$mMainHandler$1] */
    public AndroidMediaPlayer(Context context) {
        super(context);
        kotlin.jvm.internal.l.e(context, "context");
        this.context = context;
        MediaPlayer mediaPlayer = new MediaPlayer();
        this.mMediaPlayer = mediaPlayer;
        this.mListenerDispatcher = new MediaListenerDispatcher();
        HandlerThread handlerThread = new HandlerThread("OSMediaPlayer");
        this.mHandlerThread = handlerThread;
        this.mAfterReleaseTasks = new ConcurrentLinkedQueue<>();
        handlerThread.start();
        final Looper looper = handlerThread.getLooper();
        this.mHandler = new Handler(looper) { // from class: com.ifpdos.player.AndroidMediaPlayer$mHandler$1
            @Override // android.os.Handler
            public void handleMessage(Message msg) throws IOException {
                kotlin.jvm.internal.l.e(msg, "msg");
                super.handleMessage(msg);
                int i2 = msg.what;
                if (i2 == 0) {
                    Log.d("AndroidMediaPlayer", "handleMessage: datasource");
                    MediaPlayer mediaPlayer2 = this.this$0.mMediaPlayer;
                    Context context2 = this.this$0.context;
                    Object obj = msg.obj;
                    kotlin.jvm.internal.l.c(obj, "null cannot be cast to non-null type android.net.Uri");
                    mediaPlayer2.setDataSource(context2, (Uri) obj);
                    removeMessages(1);
                }
                switch (i2) {
                    case 2:
                        Log.d("AndroidMediaPlayer", "handleMessage: prepare");
                        this.this$0.mMediaPlayer.prepareAsync();
                        break;
                    case 3:
                        Log.d("AndroidMediaPlayer", "handleMessage: start");
                        this.this$0.mMediaPlayer.start();
                        break;
                    case 4:
                        Log.d("AndroidMediaPlayer", "handleMessage: pause");
                        this.this$0.mMediaPlayer.pause();
                        break;
                    case 5:
                        Log.d("AndroidMediaPlayer", "handleMessage: stop");
                        this.this$0.mMediaPlayer.stop();
                        break;
                    case 6:
                        Log.d("AndroidMediaPlayer", "handleMessage: reset");
                        this.this$0.mMediaPlayer.reset();
                        this.this$0.isReseted = true;
                        break;
                    case 7:
                        Log.d("AndroidMediaPlayer", "handleMessage: release, " + this.this$0.mAfterReleaseTasks.size());
                        this.this$0.mMediaPlayer.release();
                        while (!this.this$0.mAfterReleaseTasks.isEmpty()) {
                            Runnable runnable = (Runnable) this.this$0.mAfterReleaseTasks.poll();
                            Log.d("AndroidMediaPlayer", "handleMessage: 1");
                            if (runnable != null) {
                                try {
                                    runnable.run();
                                } catch (Exception e2) {
                                    Log.e("AndroidMediaPlayer", "Error executing after release task", e2);
                                }
                            }
                            Log.d("AndroidMediaPlayer", "handleMessage: 2");
                        }
                        break;
                    default:
                        Log.d("AndroidMediaPlayer", "handleMessage: unknown message");
                        break;
                }
            }
        };
        final Looper mainLooper = Looper.getMainLooper();
        this.mMainHandler = new Handler(mainLooper) { // from class: com.ifpdos.player.AndroidMediaPlayer$mMainHandler$1
            @Override // android.os.Handler
            public void handleMessage(Message msg) {
                kotlin.jvm.internal.l.e(msg, "msg");
                super.handleMessage(msg);
                if (msg.what == 1) {
                    this.this$0.mListenerDispatcher.onError(1, 0);
                }
            }
        };
        mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() { // from class: com.ifpdos.player.a
            @Override // android.media.MediaPlayer.OnPreparedListener
            public final void onPrepared(MediaPlayer mediaPlayer2) {
                AndroidMediaPlayer._init_$lambda$1(this.f3181a, mediaPlayer2);
            }
        });
        mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() { // from class: com.ifpdos.player.b
            @Override // android.media.MediaPlayer.OnCompletionListener
            public final void onCompletion(MediaPlayer mediaPlayer2) {
                AndroidMediaPlayer._init_$lambda$2(this.f3182a, mediaPlayer2);
            }
        });
        mediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() { // from class: com.ifpdos.player.c
            @Override // android.media.MediaPlayer.OnErrorListener
            public final boolean onError(MediaPlayer mediaPlayer2, int i2, int i3) {
                return AndroidMediaPlayer._init_$lambda$3(this.f3183a, mediaPlayer2, i2, i3);
            }
        });
        mediaPlayer.setOnSeekCompleteListener(new MediaPlayer.OnSeekCompleteListener() { // from class: com.ifpdos.player.d
            @Override // android.media.MediaPlayer.OnSeekCompleteListener
            public final void onSeekComplete(MediaPlayer mediaPlayer2) {
                AndroidMediaPlayer._init_$lambda$4(this.f3184a, mediaPlayer2);
            }
        });
        mediaPlayer.setOnInfoListener(new MediaPlayer.OnInfoListener() { // from class: com.ifpdos.player.e
            @Override // android.media.MediaPlayer.OnInfoListener
            public final boolean onInfo(MediaPlayer mediaPlayer2, int i2, int i3) {
                return AndroidMediaPlayer._init_$lambda$5(this.f3185a, mediaPlayer2, i2, i3);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void _init_$lambda$1(AndroidMediaPlayer this$0, MediaPlayer mediaPlayer) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        Log.d(TAG, "onPrepared");
        if (this$0.isOnError) {
            Log.d(TAG, "onPrepared: but isOnError");
        } else {
            this$0.isPrepared = true;
            this$0.mListenerDispatcher.onPrepare();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void _init_$lambda$2(AndroidMediaPlayer this$0, MediaPlayer mediaPlayer) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        this$0.mListenerDispatcher.onComplete();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final boolean _init_$lambda$3(AndroidMediaPlayer this$0, MediaPlayer mediaPlayer, int i2, int i3) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        Log.e(TAG, "error what:" + i2 + ", extra:" + i3);
        if (Y0.b.a() == b.a.V982 && (i2 == 804 || i2 == 805)) {
            Log.d(TAG, "onError: 982 ignore not playing error");
            return true;
        }
        this$0.mListenerDispatcher.onBuffing(false);
        return this$0.mListenerDispatcher.onError(i2, i3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void _init_$lambda$4(AndroidMediaPlayer this$0, MediaPlayer mediaPlayer) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        this$0.mListenerDispatcher.onSeekComplete();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final boolean _init_$lambda$5(AndroidMediaPlayer this$0, MediaPlayer mediaPlayer, int i2, int i3) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        Log.d(TAG, "info what:" + i2 + ", extra:" + i3);
        if (Y0.b.a() != b.a.MT9666) {
            if (i2 == 701) {
                this$0.mListenerDispatcher.onBuffing(true);
            } else if (i2 == 702) {
                this$0.mListenerDispatcher.onBuffing(false);
            }
            this$0.mListenerDispatcher.onInfo(i2, i3);
        } else if (i2 == 1002 || i2 == 1003) {
            this$0.isOnError = true;
            this$0.mListenerDispatcher.onError(i2, i3);
        }
        return true;
    }

    private final void clear() {
        removeCallbacksAndMessages(null);
        removeCallbacksAndMessages(null);
    }

    private final Parcel getInfo(int i2) {
        Parcel parcelObtain = Parcel.obtain();
        kotlin.jvm.internal.l.d(parcelObtain, "obtain(...)");
        parcelObtain.writeInterfaceToken("android.media.IMediaPlayer");
        parcelObtain.writeInt(i2);
        Parcel parcelObtain2 = Parcel.obtain();
        kotlin.jvm.internal.l.d(parcelObtain2, "obtain(...)");
        invoke(parcelObtain, parcelObtain2);
        parcelObtain2.setDataPosition(0);
        parcelObtain.recycle();
        return parcelObtain2;
    }

    private final int invoke(Parcel parcel, Parcel parcel2) {
        try {
            Z0.c.l(this.mMediaPlayer).c("invoke", parcel, parcel2);
            return 1;
        } catch (RuntimeException unused) {
            return -1;
        }
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void addMediaListener(OnMediaPlayerListener onMediaPlayerListener) {
        kotlin.jvm.internal.l.e(onMediaPlayerListener, "onMediaPlayerListener");
        this.mListenerDispatcher.add(onMediaPlayerListener);
        onMediaPlayerListener.onPlayerKernelChanged(getPlayerKernel());
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getCurrentPosition() {
        return this.mMediaPlayer.getCurrentPosition();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getDuration() {
        return this.mMediaPlayer.getDuration();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public MediaMetaDataInfo getMetaDataInfo() {
        if (Y0.b.n()) {
            Parcel info = getInfo(CMD_GET_VIDEO_INFO);
            info.readInt();
            int i2 = info.readInt();
            Log.d(TAG, "format " + i2);
            if (i2 == 36) {
                return new MediaMetaDataInfo("HEVC");
            }
        }
        return new MediaMetaDataInfo(HttpUrl.FRAGMENT_ENCODE_SET);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getVideoHeight() {
        return this.mMediaPlayer.getVideoHeight();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getVideoWidth() {
        return this.mMediaPlayer.getVideoWidth();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public boolean isPlaying() {
        return this.mMediaPlayer.isPlaying();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void pause() {
        Log.d(TAG, "pause: ");
        sendEmptyMessage(4);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void prepare() throws IOException {
        Log.d(TAG, "prepare: ");
        this.isOnError = false;
        long j2 = (PlatformUtils.INSTANCE.is982() && this.isReseted) ? 100L : 0L;
        this.isReseted = false;
        sendEmptyMessageDelayed(2, j2);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void release() {
        Log.d(TAG, "release: ");
        this.isPrepared = false;
        clear();
        sendEmptyMessage(7);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void removeMediaListener(OnMediaPlayerListener onMediaPlayerListener) {
        kotlin.jvm.internal.l.e(onMediaPlayerListener, "onMediaPlayerListener");
        this.mListenerDispatcher.remove(onMediaPlayerListener);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void reset() {
        Log.d(TAG, "reset: ");
        sendEmptyMessage(6);
    }

    public final void runAfterRelease(Runnable task) {
        kotlin.jvm.internal.l.e(task, "task");
        this.mAfterReleaseTasks.add(task);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void seekTo(int i2, boolean z2) {
        if (!this.isPrepared) {
            Log.i(TAG, "seekTo: not prepared");
            return;
        }
        if (z2) {
            this.mMediaPlayer.seekTo(i2, 3);
        } else {
            this.mMediaPlayer.seekTo(i2);
        }
        Log.v("OSMediaPlayer", "seekTo: " + i2);
    }

    @Override // com.ifpdos.player.BasePlayer, com.ifpdos.player.base.IPlayer
    public void setDataSource(Uri fileDescriptor) throws IOException {
        kotlin.jvm.internal.l.e(fileDescriptor, "fileDescriptor");
        super.setDataSource(fileDescriptor);
        Log.d(TAG, "setDataSource: ");
        AndroidMediaPlayer$mHandler$1 androidMediaPlayer$mHandler$1 = this.mHandler;
        Message messageObtain = Message.obtain();
        messageObtain.what = 0;
        messageObtain.obj = fileDescriptor;
        androidMediaPlayer$mHandler$1.sendMessage(messageObtain);
        sendEmptyMessageDelayed(1, 3000L);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void setDisplay(SurfaceHolder surface) {
        kotlin.jvm.internal.l.e(surface, "surface");
        this.mMediaPlayer.setDisplay(surface);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void setSurface(Surface surface) {
        kotlin.jvm.internal.l.e(surface, "surface");
        this.mMediaPlayer.setSurface(surface);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void start() {
        Log.d(TAG, "start: ");
        sendEmptyMessage(3);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void stop() {
        Log.d(TAG, "stop: ");
        clear();
        sendEmptyMessage(5);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void seekTo(int i2) {
        if (!this.isPrepared) {
            Log.i(TAG, "seekTo: not prepared");
            return;
        }
        this.mMediaPlayer.seekTo(i2, 3);
        Log.v("OSMediaPlayer", "seekTo: " + i2);
    }
}