package com.mstar.android.tvapi.common;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.mstar.android.tvapi.common.listener.OnMhlEventListener;
import java.lang.ref.WeakReference;

/* JADX INFO: loaded from: classes.dex */
public final class MhlManager {
    private static MhlManager _mhlManager;
    private EventHandler mEventHandler;
    private int mMhlmanagerContext;
    private long mNativeContext;
    private OnMhlEventListener mOnEventListener;

    /* JADX INFO: renamed from: com.mstar.android.tvapi.common.MhlManager$1, reason: invalid class name */
    static /* synthetic */ class AnonymousClass1 {
        static final /* synthetic */ int[] $SwitchMap$com$mstar$android$tvapi$common$MhlManager$EVENT;

        static {
            int[] iArr = new int[EVENT.values().length];
            $SwitchMap$com$mstar$android$tvapi$common$MhlManager$EVENT = iArr;
            try {
                iArr[EVENT.EV_KEY_INFO.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$mstar$android$tvapi$common$MhlManager$EVENT[EVENT.EV_AUTO_SWITCH.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
        }
    }

    protected enum EVENT {
        EV_KEY_INFO,
        EV_AUTO_SWITCH,
        EV_MAX
    }

    private class EventHandler extends Handler {
        private MhlManager mMSrv;

        public EventHandler(MhlManager mhlManager, Looper looper) {
            super(looper);
            this.mMSrv = mhlManager;
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            if (this.mMSrv.mNativeContext == 0) {
                return;
            }
            EVENT[] eventArrValues = EVENT.values();
            if (message.what > EVENT.EV_MAX.ordinal() || message.what < EVENT.EV_KEY_INFO.ordinal()) {
                Log.e(getClass().getCanonicalName(), "Native post event out of bound:" + Integer.toString(message.what));
                return;
            }
            int i2 = AnonymousClass1.$SwitchMap$com$mstar$android$tvapi$common$MhlManager$EVENT[eventArrValues[message.what].ordinal()];
            if (i2 == 1) {
                if (MhlManager.this.mOnEventListener != null) {
                    MhlManager.this.mOnEventListener.onKeyInfo(message.what, message.arg1, message.arg2);
                }
            } else if (i2 == 2) {
                if (MhlManager.this.mOnEventListener != null) {
                    MhlManager.this.mOnEventListener.onAutoSwitch(message.what, message.arg1, message.arg2);
                }
            } else {
                System.err.println("Unknown message type " + message.what);
            }
        }
    }

    static {
        try {
            System.loadLibrary("mhlmanager_jni");
            native_init();
        } catch (UnsatisfiedLinkError e2) {
            System.err.println("Cannot load mhlmanager_jni library:\n" + e2.toString());
        }
    }

    private MhlManager() {
        Looper looperMyLooper = Looper.myLooper();
        if (looperMyLooper != null) {
            this.mEventHandler = new EventHandler(this, looperMyLooper);
        } else {
            Looper mainLooper = Looper.getMainLooper();
            if (mainLooper != null) {
                this.mEventHandler = new EventHandler(this, mainLooper);
            } else {
                this.mEventHandler = null;
            }
        }
        native_setup(new WeakReference(this));
    }

    private static void PostEvent_AutoSwitch(Object obj, int i2, int i3) {
        EventHandler eventHandler;
        MhlManager mhlManager = (MhlManager) ((WeakReference) obj).get();
        if (mhlManager == null || (eventHandler = mhlManager.mEventHandler) == null) {
            return;
        }
        mhlManager.mEventHandler.sendMessage(eventHandler.obtainMessage(EVENT.EV_AUTO_SWITCH.ordinal(), i2, i3));
    }

    private static void PostEvent_KeyInfo(Object obj, int i2, int i3) {
        EventHandler eventHandler;
        MhlManager mhlManager = (MhlManager) ((WeakReference) obj).get();
        if (mhlManager == null || (eventHandler = mhlManager.mEventHandler) == null) {
            return;
        }
        mhlManager.mEventHandler.sendMessage(eventHandler.obtainMessage(EVENT.EV_KEY_INFO.ordinal(), i2, i3));
    }

    private static void PostEvent_SnServiceDeadth(Object obj, int i2, int i3) {
    }

    protected static MhlManager getInstance() {
        if (_mhlManager == null) {
            synchronized (MhlManager.class) {
                try {
                    if (_mhlManager == null) {
                        _mhlManager = new MhlManager();
                    }
                } finally {
                }
            }
        }
        return _mhlManager;
    }

    private final native void native_finalize();

    private static final native void native_init();

    private final native void native_setup(Object obj);

    private static void postEventFromNative(Object obj, int i2, int i3, int i4, Object obj2) {
        MhlManager mhlManager = (MhlManager) ((WeakReference) obj).get();
        if (mhlManager == null) {
            return;
        }
        EventHandler eventHandler = mhlManager.mEventHandler;
        if (eventHandler != null) {
            mhlManager.mEventHandler.sendMessage(eventHandler.obtainMessage(i2, i3, i4, obj2));
        }
        System.out.println("\n NativeCEC callback, postEventFromNative");
    }

    public final native boolean CbusStatus();

    public final native boolean IRKeyProcess(int i2, boolean z2);

    public final native boolean IsMhlPortInUse();

    protected void finalize() throws Throwable {
        super.finalize();
        native_finalize();
        _mhlManager = null;
    }

    public final native boolean getAutoSwitch();

    protected void release() throws Throwable {
        _mhlManager = null;
    }

    public final native void setAutoSwitch(boolean z2);

    public final native void setDebugMode(boolean z2);

    public void setOnMhlEventListener(OnMhlEventListener onMhlEventListener) {
        this.mOnEventListener = onMhlEventListener;
    }
}