package com.seewo.libmcuservice;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
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.util.Log;
import com.seewo.libmcuservice.BasicRS232Box;
import com.seewo.libmcuservice.ChannelBox;
import com.seewo.libmcuservice.EthernetBox;
import com.seewo.libmcuservice.FactoryBox;
import com.seewo.libmcuservice.HardwareBox;
import com.seewo.libmcuservice.KeyLockerBox;
import com.seewo.libmcuservice.OsdBox;
import com.seewo.libmcuservice.PCStateBox;
import com.seewo.libmcuservice.PowerBox;
import com.seewo.libmcuservice.RemoteBox;
import com.seewo.libmcuservice.SelfCheckBox;
import com.seewo.libmcuservice.TemperatureBox;
import com.seewo.libmcuservice.TimerBox;
import com.seewo.libmcuservice.TouchBox;
import com.seewo.libmcuservice.VersionBox;
import com.seewo.libmcuservice.VideoRecorderBox;
import com.seewo.libmcuservice.aidl.IMcuService;
import com.seewo.libmcuservice.aidl.model.LibMcuCallback;
import com.seewo.libmcuservice.aidl.model.ResponseCallback;
import com.seewo.libmcuservice.command.CmdBase;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class McuMailboxes {
    private static final long DELAY_CONNECT_MCU = 2000;
    private static final String INTENT_MCU_SERVICE = "com.seewo.mcuservice.McuService";
    private static final int MESSAGE_CONNECT_MCU = 100;
    private static final String PACKAGE_MCU_SERVICE = "com.seewo.mcuservice";
    private static final String TAG = "McuMailboxes";
    private static McuMailboxes mInstance;
    private static String sID;
    private Context mContext;
    private IMcuService mMcuService;
    private Handler mHandler = new Handler(Looper.getMainLooper()) { // from class: com.seewo.libmcuservice.McuMailboxes.1
        @Override // android.os.Handler
        public void handleMessage(Message message) {
            McuMailboxes.this.connectMCU();
        }
    };
    private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() { // from class: com.seewo.libmcuservice.McuMailboxes.2
        @Override // android.os.IBinder.DeathRecipient
        public void binderDied() {
            if (McuMailboxes.this.mMcuService == null) {
                return;
            }
            McuMailboxes.this.mMcuService.asBinder().unlinkToDeath(McuMailboxes.this.mDeathRecipient, 0);
            McuMailboxes.this.processWhenDisconnected();
            McuMailboxes.this.connectMCU();
        }
    };
    private ServiceConnection mMcuServiceConnection = new ServiceConnection() { // from class: com.seewo.libmcuservice.McuMailboxes.3
        @Override // android.content.ServiceConnection
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            McuMailboxes.this.mMcuService = IMcuService.Stub.asInterface(iBinder);
            if (iBinder != null) {
                try {
                    iBinder.linkToDeath(McuMailboxes.this.mDeathRecipient, 0);
                    String unused = McuMailboxes.sID = McuMailboxes.this.mMcuService.registerName(McuMailboxes.this.mContext.getPackageName());
                    McuMailboxes mcuMailboxes = McuMailboxes.this;
                    mcuMailboxes.notifyConnected(mcuMailboxes.mMcuService);
                } catch (RemoteException e2) {
                    Log.e(McuMailboxes.TAG, LibMcuApplication.REMOTE_EXCEPTION, e2);
                }
            }
        }

        @Override // android.content.ServiceConnection
        public void onServiceDisconnected(ComponentName componentName) {
            McuMailboxes.this.processWhenDisconnected();
        }
    };
    private List<AbstractConnection> mConnectionCallbacks = new LinkedList();

    private McuMailboxes() {
    }

    public static String getID() {
        return sID;
    }

    public static McuMailboxes getInstance() {
        if (mInstance == null) {
            mInstance = new McuMailboxes();
        }
        return mInstance;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void notifyConnected(IMcuService iMcuService) {
        synchronized (this.mConnectionCallbacks) {
            Iterator<AbstractConnection> it = this.mConnectionCallbacks.iterator();
            while (it.hasNext()) {
                it.next().onConnected(iMcuService);
            }
        }
    }

    private void notifyDisconnected() {
        synchronized (this.mConnectionCallbacks) {
            Iterator<AbstractConnection> it = this.mConnectionCallbacks.iterator();
            while (it.hasNext()) {
                it.next().onDisconnected();
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processWhenDisconnected() {
        String str;
        if (this.mMcuService == null) {
            return;
        }
        notifyDisconnected();
        try {
            this.mMcuService.unRegisterName(sID);
        } catch (RemoteException e2) {
            e = e2;
            str = LibMcuApplication.REMOTE_EXCEPTION;
            Log.e(TAG, str, e);
        } catch (NullPointerException e3) {
            e = e3;
            str = "Ignore Null pointer exception";
            Log.e(TAG, str, e);
        }
        this.mMcuService = null;
    }

    private void registerCallback(AbstractConnection abstractConnection) {
        IMcuService iMcuService = this.mMcuService;
        if (iMcuService != null) {
            abstractConnection.connectService(iMcuService);
        }
        synchronized (this.mConnectionCallbacks) {
            this.mConnectionCallbacks.add(abstractConnection);
        }
    }

    private void unregisterCallback(AbstractConnection abstractConnection) {
        abstractConnection.onUnregister();
        synchronized (this.mConnectionCallbacks) {
            this.mConnectionCallbacks.remove(abstractConnection);
        }
    }

    public void connectMCU() {
        if (this.mMcuService == null) {
            Intent intent = new Intent("com.seewo.mcuservice.McuService");
            intent.setPackage("com.seewo.mcuservice");
            if (this.mContext.bindService(intent, this.mMcuServiceConnection, 1)) {
                return;
            }
            this.mHandler.sendEmptyMessageDelayed(100, DELAY_CONNECT_MCU);
        }
    }

    public void disconnectMCU() {
        Iterator<AbstractConnection> it = this.mConnectionCallbacks.iterator();
        while (it.hasNext()) {
            it.next().onUnregister();
        }
        this.mConnectionCallbacks.clear();
        this.mContext.unbindService(this.mMcuServiceConnection);
        processWhenDisconnected();
    }

    public BasicRS232Box getBasicRS232Box(BasicRS232Box.BasicRS232CommandCallback basicRS232CommandCallback) {
        BasicRS232Box basicRS232Box = new BasicRS232Box(basicRS232CommandCallback);
        registerCallback(basicRS232Box.mConnection);
        return basicRS232Box;
    }

    public BootChannelBox getBootChannelBox() {
        BootChannelBox bootChannelBox = new BootChannelBox();
        registerCallback(bootChannelBox.mConnection);
        return bootChannelBox;
    }

    public ChannelBox getChannelBox(ChannelBox.AbsChannelCallback absChannelCallback) {
        ChannelBox channelBox = new ChannelBox(absChannelCallback);
        registerCallback(channelBox.mConnection);
        return channelBox;
    }

    public EthernetBox getEthernetBox(EthernetBox.AbstractEthernetCallback abstractEthernetCallback) {
        EthernetBox ethernetBox = new EthernetBox(this.mContext, abstractEthernetCallback);
        registerCallback(ethernetBox.mConnection);
        return ethernetBox;
    }

    public FactoryBox getFactoryBox(FactoryBox.AbsFactoryCallback absFactoryCallback) {
        FactoryBox factoryBox = new FactoryBox(absFactoryCallback);
        registerCallback(factoryBox.mConnection);
        return factoryBox;
    }

    public HardwareBox getHardwareBox(HardwareBox.AbsHardwareCallback absHardwareCallback) {
        HardwareBox hardwareBox = new HardwareBox(absHardwareCallback);
        registerCallback(hardwareBox.mConnection);
        return hardwareBox;
    }

    public KeyBoardControlBox getKeyBoardControlService() {
        KeyBoardControlBox keyBoardControlBox = new KeyBoardControlBox();
        registerCallback(keyBoardControlBox.mConnection);
        return keyBoardControlBox;
    }

    public KeyLockerBox getKeyLockerBox(KeyLockerBox.AbsKeyLockerCallback absKeyLockerCallback) {
        KeyLockerBox keyLockerBox = new KeyLockerBox(absKeyLockerCallback);
        registerCallback(keyLockerBox.mConnection);
        return keyLockerBox;
    }

    public OsdBox getOsdBox() {
        OsdBox osdBox = new OsdBox(this.mContext);
        registerCallback(osdBox.mConnection);
        return osdBox;
    }

    public OsdBox getOsdBox(OsdBox.AbsOsdCallBack absOsdCallBack) {
        OsdBox osdBox = new OsdBox(this.mContext, absOsdCallBack);
        registerCallback(osdBox.mConnection);
        return osdBox;
    }

    public PCStateBox getPCStateBox(PCStateBox.AbsPCStateCallback absPCStateCallback) {
        PCStateBox pCStateBox = new PCStateBox(absPCStateCallback);
        registerCallback(pCStateBox.mConnection);
        return pCStateBox;
    }

    public PowerBox getPowerBox(PowerBox.AbsPowerCallback absPowerCallback) {
        PowerBox powerBox = new PowerBox(this.mContext, absPowerCallback);
        registerCallback(powerBox.mConnection);
        return powerBox;
    }

    public RemoteBox getRemoteBox(RemoteBox.AbsRemoteCallback absRemoteCallback) {
        RemoteBox remoteBox = new RemoteBox(this.mContext, absRemoteCallback);
        registerCallback(remoteBox.mConnection);
        return remoteBox;
    }

    public SelfCheckBox getSelfCheckBox(SelfCheckBox.AbsSelfCheckCallback absSelfCheckCallback) {
        SelfCheckBox selfCheckBox = new SelfCheckBox(absSelfCheckCallback);
        registerCallback(selfCheckBox.mConnection);
        return selfCheckBox;
    }

    public TemperatureBox getTemperatureBox(TemperatureBox.AbsTemperatureCallback absTemperatureCallback) {
        TemperatureBox temperatureBox = new TemperatureBox(absTemperatureCallback);
        registerCallback(temperatureBox.mConnection);
        return temperatureBox;
    }

    public TimerBox getTimerBox(TimerBox.AbsTimerCallback absTimerCallback) {
        TimerBox timerBox = new TimerBox(absTimerCallback);
        registerCallback(timerBox.mConnection);
        return timerBox;
    }

    public TouchBox getTouchBox(TouchBox.AbsTouchCallback absTouchCallback) {
        TouchBox touchBox = new TouchBox(absTouchCallback);
        registerCallback(touchBox.mConnection);
        return touchBox;
    }

    public VersionBox getVersionBox(VersionBox.AbsVersionCallback absVersionCallback) {
        VersionBox versionBox = new VersionBox(absVersionCallback);
        registerCallback(versionBox.mConnection);
        return versionBox;
    }

    public VideoRecorderBox getVideoRecorderBox(VideoRecorderBox.AbsRecorderCallback absRecorderCallback) {
        VideoRecorderBox videoRecorderBox = new VideoRecorderBox(absRecorderCallback);
        registerCallback(videoRecorderBox.mConnection);
        return videoRecorderBox;
    }

    public void registerCallback(Bundle bundle, LibMcuCallback libMcuCallback) {
    }

    public void releaseAllBox() {
        synchronized (this.mConnectionCallbacks) {
            Iterator<AbstractConnection> it = this.mConnectionCallbacks.iterator();
            while (it.hasNext()) {
                it.next().onUnregister();
            }
            this.mConnectionCallbacks.clear();
        }
    }

    public void releaseBasicRS23Box(BasicRS232Box basicRS232Box) {
        unregisterCallback(basicRS232Box.mConnection);
    }

    public void releaseBootChannelBox(BootChannelBox bootChannelBox) {
        unregisterCallback(bootChannelBox.mConnection);
    }

    public void releaseChannelBox(ChannelBox channelBox) {
        unregisterCallback(channelBox.mConnection);
    }

    public void releaseEthernetBox(EthernetBox ethernetBox) {
        unregisterCallback(ethernetBox.mConnection);
    }

    public void releaseFactoryBox(FactoryBox factoryBox) {
        unregisterCallback(factoryBox.mConnection);
    }

    public void releaseHardwareBox(HardwareBox hardwareBox) {
        unregisterCallback(hardwareBox.mConnection);
    }

    public void releaseKeyBoardControlBox(KeyBoardControlBox keyBoardControlBox) {
        unregisterCallback(keyBoardControlBox.mConnection);
    }

    public void releaseKeyLockerBox(KeyLockerBox keyLockerBox) {
        unregisterCallback(keyLockerBox.mConnection);
    }

    public void releaseOsdBox(OsdBox osdBox) {
        unregisterCallback(osdBox.mConnection);
    }

    public void releasePCStateBox(PCStateBox pCStateBox) {
        unregisterCallback(pCStateBox.mConnection);
    }

    public void releasePowerBox(PowerBox powerBox) {
        unregisterCallback(powerBox.mConnection);
    }

    public void releaseRemoteBox(RemoteBox remoteBox) {
        unregisterCallback(remoteBox.mConnection);
    }

    public void releaseSelfCheckBox(SelfCheckBox selfCheckBox) {
        unregisterCallback(selfCheckBox.mConnection);
    }

    public void releaseTemperatureBox(TemperatureBox temperatureBox) {
        unregisterCallback(temperatureBox.mConnection);
    }

    public void releaseTimerBox(TimerBox timerBox) {
        unregisterCallback(timerBox.mConnection);
    }

    public void releaseTouchBox(TouchBox touchBox) {
        unregisterCallback(touchBox.mConnection);
    }

    public void releaseVersionBox(VersionBox versionBox) {
        unregisterCallback(versionBox.mConnection);
    }

    public void releaseVideoRecorderBox(VideoRecorderBox videoRecorderBox) {
        unregisterCallback(videoRecorderBox.mConnection);
    }

    public void sendMessage(Bundle bundle, final ResponseCallback responseCallback) {
        IMcuService iMcuService = this.mMcuService;
        if (iMcuService != null) {
            try {
                iMcuService.sendMessage(bundle, new LibMcuCallback.Stub() { // from class: com.seewo.libmcuservice.McuMailboxes.4
                    @Override // com.seewo.libmcuservice.aidl.model.LibMcuCallback
                    public void onCall(Bundle bundle2) {
                        ResponseCallback responseCallback2 = responseCallback;
                        if (responseCallback2 != null) {
                            responseCallback2.onCall(bundle2);
                        }
                    }
                });
            } catch (RemoteException e2) {
                Log.e(TAG, e2.getMessage(), e2);
            }
        }
    }

    public void sendMessage(CmdBase cmdBase, ResponseCallback responseCallback) {
        sendMessage(cmdBase.encode(), responseCallback);
    }

    public void setContext(Context context) {
        this.mContext = context;
    }

    public void unregisterCallback(Bundle bundle, LibMcuCallback libMcuCallback) {
    }
}