package com.mstar.android.tv;

import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;
import com.mstar.android.tv.IEventClient;
import com.mstar.android.tv.ITvService;
import com.mstar.android.tvapi.common.exception.TvCommonException;
import com.mstar.android.tvapi.dtv.common.CaManager;
import com.mstar.android.tvapi.dtv.vo.CACardSNInfo;
import com.mstar.android.tvapi.dtv.vo.CARatingInfo;
import com.mstar.android.tvapi.dtv.vo.CaACListInfo;
import com.mstar.android.tvapi.dtv.vo.CaDetitleChkNums;
import com.mstar.android.tvapi.dtv.vo.CaEmailContentInfo;
import com.mstar.android.tvapi.dtv.vo.CaEmailHeadInfo;
import com.mstar.android.tvapi.dtv.vo.CaEmailHeadsInfo;
import com.mstar.android.tvapi.dtv.vo.CaEmailSpaceInfo;
import com.mstar.android.tvapi.dtv.vo.CaEntitleIDs;
import com.mstar.android.tvapi.dtv.vo.CaFeedDataInfo;
import com.mstar.android.tvapi.dtv.vo.CaIPPVProgramInfos;
import com.mstar.android.tvapi.dtv.vo.CaLockService;
import com.mstar.android.tvapi.dtv.vo.CaOperatorChildStatus;
import com.mstar.android.tvapi.dtv.vo.CaOperatorIds;
import com.mstar.android.tvapi.dtv.vo.CaOperatorInfo;
import com.mstar.android.tvapi.dtv.vo.CaServiceEntitles;
import com.mstar.android.tvapi.dtv.vo.CaSlotIDs;
import com.mstar.android.tvapi.dtv.vo.CaSlotInfo;
import com.mstar.android.tvapi.dtv.vo.CaStartIPPVBuyDlgInfo;
import com.mstar.android.tvapi.dtv.vo.CaStopIPPVBuyDlgInfo;
import com.mstar.android.tvapi.dtv.vo.CaWorkTimeInfo;
import java.util.ArrayList;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
public class TvCaManager extends IEventClient.Stub {
    private static final String TAG = "TvCaManager";
    public static final int TVCA_ACTION_REQUEST = 3002;
    private static final int TVCA_DETITLE_EVENT_END = 5999;
    private static final int TVCA_DETITLE_EVENT_START = 5000;
    public static final int TVCA_DETITLE_RECEIVED = 5001;
    private static final int TVCA_EMAIL_EVENT_END = 1999;
    private static final int TVCA_EMAIL_EVENT_START = 1000;
    public static final int TVCA_EMAIL_NOTIFY_ICON = 1001;
    public static final int TVCA_ENTITLE_CHANGED = 4001;
    private static final int TVCA_ENTITLE_EVENT_END = 4999;
    private static final int TVCA_ENTITLE_EVENT_START = 4000;
    public static final int TVCA_HIDE_OSD_MESSAGE = 2002;
    private static final int TVCA_IPPV_DIALOG_EVENT_END = 999;
    private static final int TVCA_IPPV_DIALOG_EVENT_START = 0;
    public static final int TVCA_IPPV_HIDE_DIALOG = 2;
    public static final int TVCA_IPPV_SHOW_BUY_DIALOG = 1;
    private static final int TVCA_LOCK_EVENT_END = 6999;
    private static final int TVCA_LOCK_EVENT_START = 6000;
    public static final int TVCA_LOCK_SERVICE = 6001;
    private static final int TVCA_OSD_MESSAGE_EVENT_END = 2999;
    private static final int TVCA_OSD_MESSAGE_EVENT_START = 2000;
    private static final int TVCA_OTA_EVENT_END = 7999;
    private static final int TVCA_OTA_EVENT_START = 7000;
    public static final int TVCA_OTA_STATE = 7001;
    private static final int TVCA_REQUEST_EVENT_END = 3999;
    private static final int TVCA_REQUEST_EVENT_START = 3000;
    public static final int TVCA_REQUEST_FEEDING = 3001;
    public static final int TVCA_SHOW_BUY_MESSAGE = 2003;
    public static final int TVCA_SHOW_FINGER_MESSAGE = 2004;
    public static final int TVCA_SHOW_OSD_MESSAGE = 2001;
    public static final int TVCA_SHOW_PROGRESS_STRIP = 2005;
    public static final int TVCA_UNLOCK_SERVICE = 6002;
    static TvCaManager mInstance;
    private static ITvCa mService;
    private EventHandler mHandler;

    @Deprecated
    private ArrayList<CaManager.OnCaEventListener> mCaListeners = new ArrayList<>();
    private ArrayList<OnIppvDialogEventListener> mIppvDialogEventListeners = new ArrayList<>();
    private ArrayList<OnEmailEventListener> mEmailEventListeners = new ArrayList<>();
    private ArrayList<OnMessageEventListener> mMessageEventListeners = new ArrayList<>();
    private ArrayList<OnRequestEventListener> mRequestEventListeners = new ArrayList<>();
    private ArrayList<OnEntitleEventListener> mEntitleEventListeners = new ArrayList<>();
    private ArrayList<OnDetitleEventListener> mDetitleEventListeners = new ArrayList<>();
    private ArrayList<OnLockEventListener> mLockEventListeners = new ArrayList<>();
    private ArrayList<OnOtaEventListener> mOtaEventListeners = new ArrayList<>();

    private class EventHandler extends Handler {
        EventHandler(Looper looper) {
            super(looper);
        }

        @Override // android.os.Handler
        public void handleMessage(Message message) {
            int i2 = message.what;
            if (i2 > 0 && i2 < 999) {
                synchronized (TvCaManager.this.mIppvDialogEventListeners) {
                    try {
                        for (OnIppvDialogEventListener onIppvDialogEventListener : TvCaManager.this.mIppvDialogEventListeners) {
                            Bundle bundlePeekData = message.peekData();
                            bundlePeekData.setClassLoader(CaStartIPPVBuyDlgInfo.class.getClassLoader());
                            onIppvDialogEventListener.onIppvDialogEvent(message.what, message.arg1, message.arg2, bundlePeekData.getParcelable("messageObj"));
                        }
                    } finally {
                    }
                }
            } else if (i2 > 1000 && i2 < 1999) {
                synchronized (TvCaManager.this.mEmailEventListeners) {
                    try {
                        Iterator it = TvCaManager.this.mEmailEventListeners.iterator();
                        while (it.hasNext()) {
                            ((OnEmailEventListener) it.next()).onEmailEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            } else if (i2 > 2000 && i2 < 2999) {
                synchronized (TvCaManager.this.mMessageEventListeners) {
                    try {
                        for (OnMessageEventListener onMessageEventListener : TvCaManager.this.mMessageEventListeners) {
                            Bundle bundlePeekData2 = message.peekData();
                            bundlePeekData2.setClassLoader(String.class.getClassLoader());
                            onMessageEventListener.onMessageEvent(message.what, message.arg1, message.arg2, bundlePeekData2.getParcelable("messageObj"));
                        }
                    } finally {
                    }
                }
            } else if (i2 > 3000 && i2 < 3999) {
                synchronized (TvCaManager.this.mRequestEventListeners) {
                    try {
                        Iterator it2 = TvCaManager.this.mRequestEventListeners.iterator();
                        while (it2.hasNext()) {
                            ((OnRequestEventListener) it2.next()).onRequestEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            } else if (i2 > 4000 && i2 < 4999) {
                synchronized (TvCaManager.this.mEntitleEventListeners) {
                    try {
                        Iterator it3 = TvCaManager.this.mEntitleEventListeners.iterator();
                        while (it3.hasNext()) {
                            ((OnEntitleEventListener) it3.next()).onEntitleEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            } else if (i2 > 5000 && i2 < 5999) {
                synchronized (TvCaManager.this.mDetitleEventListeners) {
                    try {
                        Iterator it4 = TvCaManager.this.mDetitleEventListeners.iterator();
                        while (it4.hasNext()) {
                            ((OnDetitleEventListener) it4.next()).onDetitleEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            } else if (i2 > 6000 && i2 < 6999) {
                synchronized (TvCaManager.this.mLockEventListeners) {
                    try {
                        for (OnLockEventListener onLockEventListener : TvCaManager.this.mLockEventListeners) {
                            Bundle bundlePeekData3 = message.peekData();
                            bundlePeekData3.setClassLoader(CaLockService.class.getClassLoader());
                            onLockEventListener.onLockEvent(message.what, message.arg1, message.arg2, bundlePeekData3.getParcelable("messageObj"));
                        }
                    } finally {
                    }
                }
            } else if (i2 > 7000 && i2 < 7999) {
                synchronized (TvCaManager.this.mOtaEventListeners) {
                    try {
                        Iterator it5 = TvCaManager.this.mOtaEventListeners.iterator();
                        while (it5.hasNext()) {
                            ((OnOtaEventListener) it5.next()).onOtaEvent(message.what, message.arg1, message.arg2, message.obj);
                        }
                    } finally {
                    }
                }
            }
            int i3 = message.what;
            if (i3 == 1) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        for (CaManager.OnCaEventListener onCaEventListener : TvCaManager.this.mCaListeners) {
                            Bundle bundlePeekData4 = message.peekData();
                            bundlePeekData4.setClassLoader(CaStartIPPVBuyDlgInfo.class.getClassLoader());
                            onCaEventListener.onStartIppvBuyDlg(CaManager.getInstance(), message.what, message.arg1, message.arg2, (CaStartIPPVBuyDlgInfo) bundlePeekData4.getParcelable("messageObj"));
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 2) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it6 = TvCaManager.this.mCaListeners.iterator();
                        while (it6.hasNext()) {
                            ((CaManager.OnCaEventListener) it6.next()).onHideIPPVDlg(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 1001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it7 = TvCaManager.this.mCaListeners.iterator();
                        while (it7.hasNext()) {
                            ((CaManager.OnCaEventListener) it7.next()).onEmailNotifyIcon(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 4001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it8 = TvCaManager.this.mCaListeners.iterator();
                        while (it8.hasNext()) {
                            ((CaManager.OnCaEventListener) it8.next()).onEntitleChanged(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 5001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it9 = TvCaManager.this.mCaListeners.iterator();
                        while (it9.hasNext()) {
                            ((CaManager.OnCaEventListener) it9.next()).onDetitleReceived(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 7001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it10 = TvCaManager.this.mCaListeners.iterator();
                        while (it10.hasNext()) {
                            ((CaManager.OnCaEventListener) it10.next()).onOtaState(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 3001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it11 = TvCaManager.this.mCaListeners.iterator();
                        while (it11.hasNext()) {
                            ((CaManager.OnCaEventListener) it11.next()).onRequestFeeding(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 3002) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it12 = TvCaManager.this.mCaListeners.iterator();
                        while (it12.hasNext()) {
                            ((CaManager.OnCaEventListener) it12.next()).onActionRequest(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 6001) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        for (CaManager.OnCaEventListener onCaEventListener2 : TvCaManager.this.mCaListeners) {
                            Bundle bundlePeekData5 = message.peekData();
                            bundlePeekData5.setClassLoader(CaLockService.class.getClassLoader());
                            onCaEventListener2.onLockService(CaManager.getInstance(), message.what, message.arg1, message.arg2, (CaLockService) bundlePeekData5.getParcelable("messageObj"));
                        }
                    } finally {
                    }
                }
                return;
            }
            if (i3 == 6002) {
                synchronized (TvCaManager.this.mCaListeners) {
                    try {
                        Iterator it13 = TvCaManager.this.mCaListeners.iterator();
                        while (it13.hasNext()) {
                            ((CaManager.OnCaEventListener) it13.next()).onUNLockService(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                        }
                    } finally {
                    }
                }
                return;
            }
            switch (i3) {
                case 2001:
                    synchronized (TvCaManager.this.mCaListeners) {
                        try {
                            for (CaManager.OnCaEventListener onCaEventListener3 : TvCaManager.this.mCaListeners) {
                                Bundle bundlePeekData6 = message.peekData();
                                bundlePeekData6.setClassLoader(String.class.getClassLoader());
                                onCaEventListener3.onShowOSDMessage(CaManager.getInstance(), message.what, message.arg1, message.arg2, (String) bundlePeekData6.getParcelable("messageObj"));
                            }
                        } finally {
                        }
                        break;
                    }
                    return;
                case 2002:
                    synchronized (TvCaManager.this.mCaListeners) {
                        try {
                            Iterator it14 = TvCaManager.this.mCaListeners.iterator();
                            while (it14.hasNext()) {
                                ((CaManager.OnCaEventListener) it14.next()).onHideOSDMessage(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                            }
                        } finally {
                        }
                        break;
                    }
                    return;
                case 2003:
                    synchronized (TvCaManager.this.mCaListeners) {
                        try {
                            Iterator it15 = TvCaManager.this.mCaListeners.iterator();
                            while (it15.hasNext()) {
                                ((CaManager.OnCaEventListener) it15.next()).onShowBuyMessage(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                            }
                        } finally {
                        }
                        break;
                    }
                    return;
                case 2004:
                    synchronized (TvCaManager.this.mCaListeners) {
                        try {
                            Iterator it16 = TvCaManager.this.mCaListeners.iterator();
                            while (it16.hasNext()) {
                                ((CaManager.OnCaEventListener) it16.next()).onShowFingerMessage(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                            }
                        } finally {
                        }
                        break;
                    }
                    return;
                case 2005:
                    synchronized (TvCaManager.this.mCaListeners) {
                        try {
                            Iterator it17 = TvCaManager.this.mCaListeners.iterator();
                            while (it17.hasNext()) {
                                ((CaManager.OnCaEventListener) it17.next()).onShowProgressStrip(CaManager.getInstance(), message.what, message.arg1, message.arg2);
                            }
                        } finally {
                        }
                        break;
                    }
                    return;
                default:
                    Log.e(TvCaManager.TAG, "Unknown message type " + message.what);
                    return;
            }
        }
    }

    public interface OnDetitleEventListener {
        boolean onDetitleEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnEmailEventListener {
        boolean onEmailEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnEntitleEventListener {
        boolean onEntitleEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnIppvDialogEventListener {
        boolean onIppvDialogEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnLockEventListener {
        boolean onLockEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnMessageEventListener {
        boolean onMessageEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnOtaEventListener {
        boolean onOtaEvent(int i2, int i3, int i4, Object obj);
    }

    public interface OnRequestEventListener {
        boolean onRequestEvent(int i2, int i3, int i4, Object obj);
    }

    private TvCaManager() throws TvCommonException {
        this.mHandler = null;
        if (true == TvServiceBinder.isNeedBindService()) {
            ITvService tvService = TvServiceBinder.getTvService();
            if (tvService == null) {
                Log.e(TAG, "TvService doesn't exist!!");
                throw new TvCommonException("TvService doesn't exist.");
            }
            try {
                mService = tvService.getTvCa();
            } catch (RemoteException e2) {
                e2.printStackTrace();
            }
        } else {
            IBinder service = ServiceManager.getService("tv");
            if (service == null) {
                Log.e(TAG, "TvService doesn't exist!!");
                throw new TvCommonException("TvService doesn't exist.");
            }
            try {
                mService = ITvService.Stub.asInterface(service).getTvCa();
            } catch (RemoteException e3) {
                e3.printStackTrace();
            }
        }
        Looper looperMyLooper = Looper.myLooper();
        if (looperMyLooper != null) {
            this.mHandler = new EventHandler(looperMyLooper);
        } else {
            Looper mainLooper = Looper.getMainLooper();
            if (mainLooper != null) {
                this.mHandler = new EventHandler(mainLooper);
            } else {
                this.mHandler = null;
            }
        }
        try {
            mService.addClient(this);
        } catch (RemoteException e4) {
            e4.printStackTrace();
        }
    }

    public static TvCaManager getInstance() {
        if (mInstance == null) {
            synchronized (TvCaManager.class) {
                if (mInstance == null) {
                    try {
                        mInstance = new TvCaManager();
                    } catch (TvCommonException e2) {
                        e2.printStackTrace();
                        return null;
                    }
                }
            }
        }
        return mInstance;
    }

    public short CaChangePin(String str, String str2) {
        Log.d(TAG, "CaChangePin(), pbyOldPin =" + str + ", pbyNewPin =" + str2);
        try {
            return (short) mService.CaChangePin(str, str2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public boolean CaDelDetitleChkNum(short s2, int i2) {
        Log.d(TAG, "CaDelDetitleChkNum(), wTvsID =" + ((int) s2) + ", dwDetitleChkNum =" + i2);
        try {
            return mService.CaDelDetitleChkNum(s2, i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public void CaDelEmail(int i2) {
        Log.d(TAG, "CaDelEmail(), dwEmailID =" + i2);
        try {
            mService.CaDelEmail(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public CaACListInfo CaGetACList(short s2) {
        Log.d(TAG, "CaGetACList(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetACList(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CACardSNInfo CaGetCardSN() {
        Log.d(TAG, "CaGetCardSN()");
        try {
            return mService.CaGetCardSN();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaDetitleChkNums CaGetDetitleChkNums(short s2) {
        Log.d(TAG, "CaGetDetitleChkNums(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetDetitleChkNums(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public boolean CaGetDetitleReaded(short s2) {
        Log.d(TAG, "CaGetDetitleReaded(), wTvsID =" + ((int) s2));
        try {
            return mService.CaGetDetitleReaded(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public CaEmailContentInfo CaGetEmailContent(int i2) {
        Log.d(TAG, "CaGetEmailContent(), dwEmailID =" + i2);
        try {
            return mService.CaGetEmailContent(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaEmailHeadInfo CaGetEmailHead(int i2) {
        Log.d(TAG, "CaGetEmailHead(), dwEmailID =" + i2);
        try {
            return mService.CaGetEmailHead(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaEmailHeadsInfo CaGetEmailHeads(short s2, short s3) {
        Log.d(TAG, "CaGetEmailHeads(), byCount =" + ((int) s2) + ", byFromIndex=" + ((int) s3));
        try {
            return mService.CaGetEmailHeads(s2, s3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaEmailSpaceInfo CaGetEmailSpaceInfo() {
        Log.d(TAG, "CaGetEmailSpaceInfo()");
        try {
            return mService.CaGetEmailSpaceInfo();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaEntitleIDs CaGetEntitleIDs(short s2) {
        Log.d(TAG, "CaGetEntitleIDs(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetEntitleIDs(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaIPPVProgramInfos CaGetIPPVProgram(short s2) {
        Log.d(TAG, "CaGetIPPVProgram(), wTvsID =" + ((int) s2));
        try {
            return mService.CaGetIPPVProgram(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaOperatorChildStatus CaGetOperatorChildStatus(short s2) {
        Log.d(TAG, "CaGetOperatorChildStatus(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetOperatorChildStatus(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaOperatorIds CaGetOperatorIds() {
        Log.d(TAG, "CaGetOperatorIds()");
        try {
            return mService.CaGetOperatorIds();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaOperatorInfo CaGetOperatorInfo(short s2) {
        Log.d(TAG, "CaGetOperatorInfo(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetOperatorInfo(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public short CaGetPlatformID() {
        Log.d(TAG, "CaGetPlatformID()");
        try {
            return (short) mService.CaGetPlatformID();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public CARatingInfo CaGetRating() {
        Log.d(TAG, "CaGetRating()");
        try {
            return mService.CaGetRating();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaServiceEntitles CaGetServiceEntitles(short s2) {
        Log.d(TAG, "CaGetServiceEntitles(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetServiceEntitles(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaSlotIDs CaGetSlotIDs(short s2) {
        Log.d(TAG, "CaGetSlotIDs(), wTVSID =" + ((int) s2));
        try {
            return mService.CaGetSlotIDs(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public CaSlotInfo CaGetSlotInfo(short s2, short s3) {
        Log.d(TAG, "CaGetSlotInfo(), wTVSID =" + ((int) s2) + ", bySlotID" + ((int) s3));
        try {
            return mService.CaGetSlotInfo(s2, s3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public int CaGetVer() {
        Log.d(TAG, "CaGetVer()");
        try {
            return mService.CaGetVer();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return 0;
        }
    }

    public CaWorkTimeInfo CaGetWorkTime() {
        Log.d(TAG, "CaGetWorkTime()");
        try {
            return mService.CaGetWorkTime();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public short CaIsPaired(short s2, String str) {
        Log.d(TAG, "CaIsPaired(), pbyNum =" + ((int) s2) + ", pbySTBID_List =" + str);
        try {
            return (short) mService.CaIsPaired(s2, str);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public boolean CaOTAStateConfirm(int i2, int i3) {
        Log.d(TAG, "CaOTAStateConfirm(), arg1 =" + i2 + ", arg2 =" + i3);
        try {
            return mService.CaOTAStateConfirm(i2, i3);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    public CaFeedDataInfo CaReadFeedDataFromParent(short s2) {
        Log.d(TAG, "CaReadFeedDataFromParent(), wTVSID =" + ((int) s2));
        try {
            return mService.CaReadFeedDataFromParent(s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return null;
        }
    }

    public void CaRefreshInterface() {
        Log.d(TAG, "CaRefreshInterface()");
        try {
            mService.CaRefreshInterface();
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public short CaSetRating(String str, short s2) {
        Log.d(TAG, "CaSetRating(), pbyPin =" + str + ", byRating =" + ((int) s2));
        try {
            return (short) mService.CaSetRating(str, s2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public short CaSetWorkTime(String str, CaWorkTimeInfo caWorkTimeInfo) {
        Log.d(TAG, "CaSetWorkTime(), pbyPin =" + str);
        try {
            return (short) mService.CaSetWorkTime(str, caWorkTimeInfo);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public short CaStopIPPVBuyDlg(CaStopIPPVBuyDlgInfo caStopIPPVBuyDlgInfo) {
        Log.d(TAG, "CaStopIPPVBuyDlg()");
        try {
            return (short) mService.CaStopIPPVBuyDlg(caStopIPPVBuyDlgInfo);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    public short CaWriteFeedDataToChild(short s2, CaFeedDataInfo caFeedDataInfo) {
        Log.d(TAG, "CaWriteFeedDataToChild(), wTVSID =" + ((int) s2));
        try {
            return (short) mService.CaWriteFeedDataToChild(s2, caFeedDataInfo);
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return (short) 0;
        }
    }

    protected void finalize() throws Throwable {
        Log.d(TAG, "finalize TvCaManager ");
        try {
            mService.removeClient(this);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public int getCurrentEvent() {
        Log.d(TAG, "getCurrentEvent()");
        try {
            return mService.getCurrentEvent();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return 0;
        }
    }

    public int getCurrentMsgType() {
        Log.d(TAG, "getCurrentMsgType()");
        try {
            return mService.getCurrentMsgType();
        } catch (RemoteException e2) {
            e2.printStackTrace();
            return 0;
        }
    }

    @Override // com.mstar.android.tv.IEventClient
    public boolean onEvent(Message message) throws RemoteException {
        EventHandler eventHandler = this.mHandler;
        if (eventHandler == null) {
            return true;
        }
        Message messageObtainMessage = eventHandler.obtainMessage();
        messageObtainMessage.copyFrom(message);
        this.mHandler.sendMessage(messageObtainMessage);
        return true;
    }

    @Deprecated
    public boolean registerOnCaEventListener(CaManager.OnCaEventListener onCaEventListener) {
        Log.d(TAG, "registerOnCaEventListener");
        synchronized (this.mCaListeners) {
            this.mCaListeners.add(onCaEventListener);
        }
        return true;
    }

    public boolean registerOnDetitleEventListener(OnDetitleEventListener onDetitleEventListener) {
        Log.d(TAG, "registerOnDetitleEventListener");
        synchronized (this.mDetitleEventListeners) {
            this.mDetitleEventListeners.add(onDetitleEventListener);
        }
        return true;
    }

    public boolean registerOnEmailEventListener(OnEmailEventListener onEmailEventListener) {
        Log.d(TAG, "registerOnEmailEventListener");
        synchronized (this.mEmailEventListeners) {
            this.mEmailEventListeners.add(onEmailEventListener);
        }
        return true;
    }

    public boolean registerOnEntitleEventListener(OnEntitleEventListener onEntitleEventListener) {
        Log.d(TAG, "registerOnEntitleEventListener");
        synchronized (this.mEntitleEventListeners) {
            this.mEntitleEventListeners.add(onEntitleEventListener);
        }
        return true;
    }

    public boolean registerOnIppvDialogEventListener(OnIppvDialogEventListener onIppvDialogEventListener) {
        Log.d(TAG, "registerOnIppvDialogEventListener");
        synchronized (this.mIppvDialogEventListeners) {
            this.mIppvDialogEventListeners.add(onIppvDialogEventListener);
        }
        return true;
    }

    public boolean registerOnLockEventListener(OnLockEventListener onLockEventListener) {
        Log.d(TAG, "registerOnLockEventListener");
        synchronized (this.mLockEventListeners) {
            this.mLockEventListeners.add(onLockEventListener);
        }
        return true;
    }

    public boolean registerOnMessageEventListener(OnMessageEventListener onMessageEventListener) {
        Log.d(TAG, "registerOnMessageEventListener");
        synchronized (this.mMessageEventListeners) {
            this.mMessageEventListeners.add(onMessageEventListener);
        }
        return true;
    }

    public boolean registerOnOtaEventListener(OnOtaEventListener onOtaEventListener) {
        Log.d(TAG, "registerOnOtaEventListener");
        synchronized (this.mOtaEventListeners) {
            this.mOtaEventListeners.add(onOtaEventListener);
        }
        return true;
    }

    public boolean registerOnRequestEventListener(OnRequestEventListener onRequestEventListener) {
        Log.d(TAG, "registerOnRequestEventListener");
        synchronized (this.mRequestEventListeners) {
            this.mRequestEventListeners.add(onRequestEventListener);
        }
        return true;
    }

    public void setCurrentEvent(int i2) {
        Log.d(TAG, "setCurrentEvent(), CurrentEvent =" + i2);
        try {
            mService.setCurrentEvent(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public void setCurrentMsgType(int i2) {
        Log.d(TAG, "setCurrentMsgType(), MsgType =" + i2);
        try {
            mService.setCurrentMsgType(i2);
        } catch (RemoteException e2) {
            e2.printStackTrace();
        }
    }

    public synchronized boolean unregisterOnCaEventListener(CaManager.OnCaEventListener onCaEventListener) {
        synchronized (this.mCaListeners) {
            this.mCaListeners.remove(onCaEventListener);
            Log.d(TAG, "unregisterOnCaEventListener  size: " + this.mCaListeners.size());
        }
        return true;
    }

    public boolean unregisterOnDetitleEventListener(OnDetitleEventListener onDetitleEventListener) {
        synchronized (this.mDetitleEventListeners) {
            this.mDetitleEventListeners.remove(onDetitleEventListener);
            Log.d(TAG, "unregisterOnDetitleEventListener  size: " + this.mDetitleEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnEmailEventListener(OnEmailEventListener onEmailEventListener) {
        synchronized (this.mEmailEventListeners) {
            this.mEmailEventListeners.remove(onEmailEventListener);
            Log.d(TAG, "unregisterOnEmailEventListener  size: " + this.mEmailEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnEntitleEventListener(OnEntitleEventListener onEntitleEventListener) {
        synchronized (this.mEntitleEventListeners) {
            this.mEntitleEventListeners.remove(onEntitleEventListener);
            Log.d(TAG, "unregisterOnEntitleEventListener  size: " + this.mEntitleEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnIppvDialogEventListener(OnIppvDialogEventListener onIppvDialogEventListener) {
        synchronized (this.mIppvDialogEventListeners) {
            this.mIppvDialogEventListeners.remove(onIppvDialogEventListener);
            Log.d(TAG, "unregisterOnIppvDialogEventListener  size: " + this.mIppvDialogEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnLockEventListener(OnLockEventListener onLockEventListener) {
        synchronized (this.mLockEventListeners) {
            this.mLockEventListeners.remove(onLockEventListener);
            Log.d(TAG, "unregisterOnLockEventListener  size: " + this.mLockEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnMessageEventListener(OnMessageEventListener onMessageEventListener) {
        synchronized (this.mMessageEventListeners) {
            this.mMessageEventListeners.remove(onMessageEventListener);
            Log.d(TAG, "unregisterOnMessageEventListener  size: " + this.mMessageEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnOtaEventListener(OnOtaEventListener onOtaEventListener) {
        synchronized (this.mOtaEventListeners) {
            this.mOtaEventListeners.remove(onOtaEventListener);
            Log.d(TAG, "unregisterOnOtaEventListener  size: " + this.mOtaEventListeners.size());
        }
        return true;
    }

    public boolean unregisterOnRequestEventListener(OnRequestEventListener onRequestEventListener) {
        synchronized (this.mRequestEventListeners) {
            this.mRequestEventListeners.remove(onRequestEventListener);
            Log.d(TAG, "unregisterOnRequestEventListener  size: " + this.mRequestEventListeners.size());
        }
        return true;
    }
}