package com.mstar.android.tvapi.common;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.text.format.Time;
import android.util.Log;
import com.mstar.android.tvapi.common.exception.TvCommonException;
import com.mstar.android.tvapi.common.listener.OnEventListener;
import com.mstar.android.tvapi.common.vo.EnumEpgTimerActType;
import com.mstar.android.tvapi.common.vo.EnumOffTimerMode;
import com.mstar.android.tvapi.common.vo.EnumSleepTimeState;
import com.mstar.android.tvapi.common.vo.EpgEventTimerInfo;
import com.mstar.android.tvapi.common.vo.TimeZoneChangeInfo;
import com.mstar.android.tvapi.common.vo.TimerPowerOffModeStatus;
import com.mstar.android.tvapi.common.vo.TimerPowerOn;
import com.mstar.android.tvapi.common.vo.TvOsType;
import com.mstar.android.tvapi.dtv.vo.EnumEpgTimerCheck;
import java.lang.ref.WeakReference;

/* JADX INFO: loaded from: classes.dex */
public final class TimerManager {
    public static final int LINUX_TIMESOURCE_DTV = 0;
    public static final int LINUX_TIMESOURCE_MANUAL = 2;
    public static final int LINUX_TIMESOURCE_NTP = 1;
    private static final String TAG = "TimerManager";
    private static final int TVTIMER_BEAT_ONE_SECOND = 4;
    private static final int TVTIMER_DESTROY_COUNTDOWN = 0;
    private static final int TVTIMER_EPG_TIMER_COUNTDOWN = 8;
    private static final int TVTIMER_EPG_TIMER_RECORD_START = 9;
    private static final int TVTIMER_EPG_TIME_UP = 7;
    public static final int TVTIMER_KILL_LASTMINUTE = 13;
    private static final int TVTIMER_LAST_MINUTE_UPDATE = 2;
    private static final int TVTIMER_LAST_MINUTE_WARN = 1;
    private static final int TVTIMER_OAD_TIME_SCAN = 11;
    private static final int TVTIMER_POWER_DOWNTIME = 3;
    private static final int TVTIMER_PVR_NOTIFY_RECORD_STOP = 10;
    private static final int TVTIMER_SIGNAL_LOCK = 6;
    private static final int TVTIMER_SYSTEM_CLOCK_CHANGE = 5;
    public static final int TVTIMER_TIME_ZONE_CHG = 12;
    private static TimerManager _timerManager;
    private EventHandler mEventHandler;
    private long mNativeContext;
    private int mTimerManagerContext;
    private OnTimerEventListener mOnTimerEventListener = null;
    private OnEventListener mOnEventListener = null;

    private class EventHandler extends Handler {
        private TimerManager mTimerManager;

        public EventHandler(TimerManager timerManager, Looper looper) {
            super(looper);
            this.mTimerManager = timerManager;
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            if (this.mTimerManager.mNativeContext == 0) {
            }
            if (TimerManager.this.mOnEventListener != null) {
                TimerManager.this.mOnEventListener.onEvent(message);
            }
            switch (message.what) {
                case 0:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onDestroyCountDown(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 1:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onLastMinuteWarn(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 2:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onUpdateLastMinute(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 3:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onPowerDownTime(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 4:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onOneSecondBeat(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 5:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onSystemClkChg(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 6:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onSignalLock(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 7:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onEpgTimeUp(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 8:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onEpgTimerCountDown(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 9:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onEpgTimerRecordStart(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 10:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onPvrNotifyRecordStop(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
                case 11:
                    if (TimerManager.this.mOnTimerEventListener != null) {
                        TimerManager.this.mOnTimerEventListener.onOadTimeScan(this.mTimerManager, message.what, message.arg1, message.arg2);
                    }
                    break;
            }
        }
    }

    public interface OnTimerEventListener {
        boolean onDestroyCountDown(TimerManager timerManager, int i2, int i3, int i4);

        boolean onEpgTimeUp(TimerManager timerManager, int i2, int i3, int i4);

        boolean onEpgTimerCountDown(TimerManager timerManager, int i2, int i3, int i4);

        boolean onEpgTimerRecordStart(TimerManager timerManager, int i2, int i3, int i4);

        boolean onLastMinuteWarn(TimerManager timerManager, int i2, int i3, int i4);

        boolean onOadTimeScan(TimerManager timerManager, int i2, int i3, int i4);

        boolean onOneSecondBeat(TimerManager timerManager, int i2, int i3, int i4);

        boolean onPowerDownTime(TimerManager timerManager, int i2, int i3, int i4);

        boolean onPvrNotifyRecordStop(TimerManager timerManager, int i2, int i3, int i4);

        boolean onSignalLock(TimerManager timerManager, int i2, int i3, int i4);

        boolean onSystemClkChg(TimerManager timerManager, int i2, int i3, int i4);

        boolean onUpdateLastMinute(TimerManager timerManager, int i2, int i3, int i4);
    }

    static {
        try {
            System.loadLibrary("timermanager_jni");
            native_init();
        } catch (UnsatisfiedLinkError e2) {
            e2.printStackTrace();
            Log.e(TAG, "Cannot load timermanager_jni library: " + e2.toString());
        }
        _timerManager = null;
    }

    private TimerManager() {
        this.mEventHandler = null;
        Looper looperMyLooper = Looper.myLooper();
        if (looperMyLooper != null) {
            this.mEventHandler = new EventHandler(this, looperMyLooper);
        } else {
            looperMyLooper = Looper.getMainLooper();
            if (looperMyLooper != null) {
                this.mEventHandler = new EventHandler(this, looperMyLooper);
            } else {
                this.mEventHandler = null;
            }
        }
        StringBuilder sb = new StringBuilder();
        sb.append("looper is null ");
        sb.append(looperMyLooper == null);
        Log.d(TAG, sb.toString());
        native_setup(new WeakReference(this));
    }

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

    private final native int native_addEpgEvent(EpgEventTimerInfo epgEventTimerInfo) throws TvCommonException;

    private native void native_disablePowerOffMode(int i2) throws TvCommonException;

    private final native void native_finalize();

    private final native int native_getSleeperState() throws TvCommonException;

    private final native int native_getTimeZone() throws TvCommonException;

    private static final native void native_init();

    private final native int native_isEpgTimerSettingValid(EpgEventTimerInfo epgEventTimerInfo) throws TvCommonException;

    private final native void native_setOnTime(TimerPowerOn timerPowerOn, boolean z2, boolean z3, int i2) throws TvCommonException;

    private final native void native_setSleepModeTime(int i2) throws TvCommonException;

    private final native void native_setTimeZone(int i2, boolean z2) throws TvCommonException;

    private final native void native_setup(Object obj);

    private static void postEventFromNative(Object obj, int i2, int i3, int i4, Object obj2) {
        EventHandler eventHandler;
        TimerManager timerManager = (TimerManager) ((WeakReference) obj).get();
        if (timerManager == null || (eventHandler = timerManager.mEventHandler) == null) {
            return;
        }
        timerManager.mEventHandler.sendMessage(eventHandler.obtainMessage(i2, i3, i4, obj2));
    }

    private static void postEvent_TimeZoneChg(Object obj, TimeZoneChangeInfo timeZoneChangeInfo) {
        EventHandler eventHandler;
        TimerManager timerManager = (TimerManager) ((WeakReference) obj).get();
        if (timerManager == null || (eventHandler = timerManager.mEventHandler) == null) {
            return;
        }
        timerManager.mEventHandler.sendMessage(eventHandler.obtainMessage(12, timeZoneChangeInfo));
    }

    public EnumEpgTimerCheck addEpgEvent(EpgEventTimerInfo epgEventTimerInfo) throws TvCommonException {
        int iNative_addEpgEvent = native_addEpgEvent(epgEventTimerInfo);
        if (iNative_addEpgEvent < EnumEpgTimerCheck.E_NONE.ordinal() || iNative_addEpgEvent > EnumEpgTimerCheck.E_FULL.ordinal()) {
            throw new TvCommonException("native_addEpgEvent failed");
        }
        return EnumEpgTimerCheck.values()[iNative_addEpgEvent];
    }

    public final native void cancelEpgTimerEvent(int i2, boolean z2) throws TvCommonException;

    public final native int convertGPSTime2UTC(int i2) throws TvCommonException;

    public final native Time convertSeconds2StTime(int i2) throws TvCommonException;

    public final native int convertStTime2Seconds(Time time) throws TvCommonException;

    public final native int convertUTCTime2GPS(int i2) throws TvCommonException;

    public final native boolean delAllEpgEvent() throws TvCommonException;

    public final native boolean delEpgEvent(int i2) throws TvCommonException;

    public final native boolean deletePastEpgTimer() throws TvCommonException;

    public final void disablePowerOffMode(EnumOffTimerMode enumOffTimerMode) throws TvCommonException {
        native_disablePowerOffMode(enumOffTimerMode.ordinal());
    }

    public final native boolean execEpgTimerAction() throws TvCommonException;

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

    public final native Time getClkTime() throws TvCommonException;

    public native int getClockOffset() throws TvCommonException;

    public native boolean getDaylightSavingState() throws TvCommonException;

    public final native EpgEventTimerInfo getEpgTimerEventByIndex(int i2) throws TvCommonException;

    public final native int getEpgTimerEventCount() throws TvCommonException;

    public final native EpgEventTimerInfo getEpgTimerRecordingProgram() throws TvCommonException;

    public final native int getNextNDayClkTimeInSeconds(short s2) throws TvCommonException;

    public final native TimerPowerOffModeStatus getOffModeStatus() throws TvCommonException;

    public final native TimerPowerOn getOnTime() throws TvCommonException;

    public native int getRtcClock() throws TvCommonException;

    public final native int getRunningTime() throws TvCommonException;

    public final native short getSleepModeTime() throws TvCommonException;

    public EnumSleepTimeState getSleeperState() throws TvCommonException {
        int iNative_getSleeperState = native_getSleeperState();
        if (iNative_getSleeperState < EnumSleepTimeState.E_OFF.ordinal() || iNative_getSleeperState > EnumSleepTimeState.E_TOTAL.ordinal()) {
            throw new TvCommonException("getSleeperState failed");
        }
        return EnumSleepTimeState.values()[iNative_getSleeperState];
    }

    public final native Time getStClkTime() throws TvCommonException;

    public final native Time getStOnTime() throws TvCommonException;

    public final TvOsType.EnumTimeZone getTimeZone() throws TvCommonException {
        int ordinalThroughValue = TvOsType.EnumTimeZone.getOrdinalThroughValue(native_getTimeZone());
        if (ordinalThroughValue != -1) {
            return TvOsType.EnumTimeZone.values()[ordinalThroughValue];
        }
        throw new TvCommonException("gettimezone  error");
    }

    public final native int[] getUTCTimeOffset() throws TvCommonException;

    public final native boolean isEpgScheduleRecordRemiderExist(int i2) throws TvCommonException;

    public EnumEpgTimerCheck isEpgTimerSettingValid(EpgEventTimerInfo epgEventTimerInfo) throws TvCommonException {
        int iNative_isEpgTimerSettingValid = native_isEpgTimerSettingValid(epgEventTimerInfo);
        if (iNative_isEpgTimerSettingValid < EnumEpgTimerCheck.E_NONE.ordinal() || iNative_isEpgTimerSettingValid > EnumEpgTimerCheck.E_FULL.ordinal()) {
            throw new TvCommonException("isEpgTimerSettingValid failed");
        }
        return EnumEpgTimerCheck.values()[iNative_isEpgTimerSettingValid];
    }

    public final native boolean isTimeFormat12HRs() throws TvCommonException;

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

    public final native void setClkTime(Time time, boolean z2) throws TvCommonException;

    public native void setDaylightSavingState(boolean z2) throws TvCommonException;

    public final native void setDebugMode(boolean z2) throws TvCommonException;

    public final native boolean setLinuxTimeSource(int i2) throws TvCommonException;

    public final native void setOffModeStatus(TimerPowerOffModeStatus timerPowerOffModeStatus, boolean z2) throws TvCommonException;

    public void setOnEventListener(OnEventListener onEventListener) {
        this.mOnEventListener = onEventListener;
    }

    public final void setOnTime(TimerPowerOn timerPowerOn, boolean z2, boolean z3, EnumEpgTimerActType enumEpgTimerActType) throws TvCommonException {
        native_setOnTime(timerPowerOn, z2, z3, enumEpgTimerActType.ordinal());
    }

    @Deprecated
    public void setOnTimerEventListener(OnTimerEventListener onTimerEventListener) {
        this.mOnTimerEventListener = onTimerEventListener;
    }

    public final native boolean setRunningTime(int i2) throws TvCommonException;

    public void setSleepModeTime(EnumSleepTimeState enumSleepTimeState) throws TvCommonException {
        native_setSleepModeTime(enumSleepTimeState.ordinal());
    }

    public native void setSleepTime(int i2) throws TvCommonException;

    public final native void setTimeFormat12HRs() throws TvCommonException;

    public final native void setTimeFormat24HRs() throws TvCommonException;

    public final void setTimeZone(TvOsType.EnumTimeZone enumTimeZone, boolean z2) throws TvCommonException {
        native_setTimeZone(enumTimeZone.getValue(), true);
    }
}