package com.seewo.sdk;

import android.annotation.SuppressLint;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.UserHandle;
import android.util.Log;
import com.cvte.vman.instance.InvokeCmd;
import com.seewo.sdk.interfaces.IOpenSDK;
import com.seewo.sdk.interfaces.OnSdkConnected;
import com.seewo.sdk.internal.model.ISDKService;
import com.seewo.sdk.internal.model.IWatchDogService;
import com.seewo.sdk.internal.model.LibMcuCallback;
import com.seewo.sdk.internal.model.ResponseCallback;
import com.seewo.sdk.internal.model.SDKEventType;
import com.seewo.sdk.internal.model.SDKParsable;
import com.seewo.sdk.internal.model.SDKRequest;
import com.seewo.sdk.internal.model.SDKResponse;
import com.seewo.sdk.internal.response.common.RespVoidResult;
import com.seewo.sdk.internal.utils.Constants;
import com.seewo.sdk.internal.utils.SDKServiceManager;
import com.seewo.sdk.mcu.SDKMcuDataManager;
import com.seewo.sdk.pcremotesp20.SDKPCRemoteSp20Command;
import com.seewo.sdk.sensor.SDKSensorManager;
import com.seewo.sdk.touch.SDKTouch;
import com.seewo.sdk.util.ParseUtil;
import com.seewo.sdk.util.RLog;
import com.seewo.sdk.util.pool.SDKPoolObject;
import d.b.a.a.a;
import d.i.b.b;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;

/* JADX INFO: loaded from: classes.dex */
public class OpenSDK implements IOpenSDK {
    private static final int ACTION_CONNECTED = 1002;
    private static final int ACTION_RECONNECT = 1001;
    private static final String SDK_SERVICE_PACKAGE_NAME = "com.seewo.mcuservice";
    private static final String TAG = "OpenSDK";
    private Context mContext;
    private IBinder.DeathRecipient mDeathRecipient;
    private Map<Class<?>, LibMcuCallback> mEventCallbackMaps;
    private List<IExtendCallbackRegister> mExpandCallbackRegisters;

    @SuppressLint({"HandlerLeak"})
    private Handler mHandler;
    private boolean mIsRegisterAgainNecessary;
    private ConcurrentLinkedQueue<OnSdkConnected> mOnSdkConnected;
    private LinkedList<SDKRequest> mRequestPool;
    private ISDKService mSDKService;
    private String mToken;
    private int mUserId;
    private IWatchDogService mWatchDogService;

    public static class Holder {
        private static final OpenSDK INSTANCE = new OpenSDK();

        private Holder() {
        }
    }

    public interface IExtendCallbackRegister {
        void registerCallback(Class<?> cls, LibMcuCallback libMcuCallback);

        void unregisterCallback(Class<?> cls, LibMcuCallback libMcuCallback);
    }

    public class SDKNotConnectedException extends RuntimeException {
        public SDKNotConnectedException() {
            super("Make sure OpenSDKService has been connected!!!");
        }
    }

    private void bindSDK(IBinder iBinder, int i2) throws RemoteException {
        iBinder.linkToDeath(this.mDeathRecipient, 0);
        this.mSDKService = ISDKService.Stub.asInterface(iBinder);
        String packageName = this.mContext.getPackageName();
        if (i2 != b.f3600b) {
            packageName = packageName + ":" + i2;
        }
        this.mToken = this.mSDKService.getToken(packageName, null);
        StringBuilder sbB = a.B("SDK connected. Token: ");
        sbB.append(this.mToken);
        sbB.append(" Package name: ");
        sbB.append(packageName);
        Log.i(TAG, sbB.toString());
        this.mHandler.sendEmptyMessage(ACTION_CONNECTED);
    }

    private void bindWatchDog(IBinder iBinder) throws RemoteException {
        IWatchDogService iWatchDogServiceAsInterface = IWatchDogService.Stub.asInterface(iBinder);
        this.mWatchDogService = iWatchDogServiceAsInterface;
        if (iWatchDogServiceAsInterface != null) {
            iWatchDogServiceAsInterface.bindWatchDog(new Binder(), this.mContext.getPackageName());
        }
    }

    public static OpenSDK getInstance() {
        return Holder.INSTANCE;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean innerConnect() {
        SDKServiceManager.i().reconnect();
        SDKTouch.getInstance().reConnect();
        SDKMediaDataManager.getInstance().reConnect();
        SDKSensorManager.getInstance().reConnect();
        SDKPCRemoteSp20Command.getInstance().reConnect();
        SDKMcuDataManager.getInstance().reConnect();
        IBinder service = SDKServiceManager.i().getService(Constants.SDK_SERVICE);
        IBinder service2 = SDKServiceManager.i().getService(Constants.WATCH_DOG_SERVICE);
        if (service == null) {
            return false;
        }
        try {
            bindSDK(service, this.mUserId);
            bindWatchDog(service2);
            return true;
        } catch (RemoteException e2) {
            Log.e(TAG, "REMOTE_EXCEPTION", e2);
            return false;
        }
    }

    private boolean isSDKServiceNotExist() {
        try {
            this.mContext.getPackageManager().getApplicationInfo("com.seewo.mcuservice", InvokeCmd.CMD_TOUCH_CTRL_START);
            return false;
        } catch (PackageManager.NameNotFoundException unused) {
            return true;
        }
    }

    private synchronized SDKRequest popRequest() {
        return !this.mRequestPool.isEmpty() ? this.mRequestPool.removeFirst() : new SDKRequest();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processWhenDisconnected() {
        ISDKService iSDKService = this.mSDKService;
        if (iSDKService != null) {
            iSDKService.asBinder().unlinkToDeath(this.mDeathRecipient, 0);
            this.mSDKService = null;
            this.mUserId = b.f3600b;
        }
        IWatchDogService iWatchDogService = this.mWatchDogService;
        if (iWatchDogService != null) {
            try {
                iWatchDogService.unbindWatchDog(this.mContext.getPackageName());
            } catch (RemoteException e2) {
                RLog.e(TAG, e2);
            }
        }
    }

    private synchronized void pushRequest(SDKRequest sDKRequest) {
        this.mRequestPool.addLast(sDKRequest);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void registerCallbacksAgain() {
        for (Class<?> cls : this.mEventCallbackMaps.keySet()) {
            registerCallback(cls, this.mEventCallbackMaps.get(cls));
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void startSDKService() {
        if (SDKServiceManager.i().isAllowStartSDKService()) {
            Intent intent = new Intent();
            intent.setComponent(new ComponentName("com.seewo.mcuservice", Constants.MCUSERVICE_SERVICE));
            this.mContext.startService(intent);
        }
    }

    public void addExpandCallbackRegister(IExtendCallbackRegister iExtendCallbackRegister) {
        this.mExpandCallbackRegisters.add(iExtendCallbackRegister);
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void addSDKConnectedCallback(OnSdkConnected onSdkConnected) {
        if (onSdkConnected == null) {
            return;
        }
        if (isSDKServiceNotExist() || isConnected()) {
            onSdkConnected.onSdkConnected();
        } else {
            if (this.mOnSdkConnected.contains(onSdkConnected)) {
                return;
            }
            this.mOnSdkConnected.add(onSdkConnected);
        }
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void connect(Context context) {
        connect(context, null);
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void connectAsUser(Context context, UserHandle userHandle) {
        connectAsUser(context, null, userHandle);
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void disconnect() {
        if (isSDKServiceNotExist()) {
            return;
        }
        this.mHandler.removeCallbacksAndMessages(null);
        processWhenDisconnected();
    }

    public Context getContext() {
        return this.mContext;
    }

    public String getToken() {
        return this.mToken;
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public boolean isConnected() {
        return this.mSDKService != null;
    }

    public boolean postCommand(SDKParsable sDKParsable, final ResponseCallback responseCallback) {
        boolean z = true;
        if (!isSDKServiceNotExist()) {
            if (this.mSDKService != null) {
                try {
                    SDKRequest sDKRequestPopRequest = popRequest();
                    sDKRequestPopRequest.setRequestName(ParseUtil.getClassName(sDKParsable));
                    sDKRequestPopRequest.setParamsJson(ParseUtil.encodeJSON(sDKParsable));
                    this.mSDKService.postMessage(this.mToken, ParseUtil.encodeJSON(sDKRequestPopRequest), new LibMcuCallback.Stub() { // from class: com.seewo.sdk.OpenSDK.3
                        @Override // com.seewo.sdk.internal.model.LibMcuCallback
                        public void onCall(String str) throws RemoteException {
                            ResponseCallback responseCallback2 = responseCallback;
                            if (responseCallback2 != null) {
                                responseCallback2.onCall((SDKResponse) ParseUtil.decodeJSON(str, SDKResponse.class));
                            }
                        }
                    });
                    pushRequest(sDKRequestPopRequest);
                } catch (RemoteException e2) {
                    Log.e(TAG, e2.getMessage(), e2);
                    z = false;
                }
            } else {
                StringBuilder sbB = a.B("SDKService not found! \n[");
                sbB.append(this.mContext.getPackageName());
                sbB.append("]");
                Log.e(TAG, sbB.toString());
                Log.e(TAG, "[postCommand] " + sDKParsable.getClass().getSimpleName());
                if (responseCallback != null) {
                    responseCallback.onCall(new SDKResponse(SDKResponse.Status.SERVICE_NOT_FOUND));
                }
            }
            z = false;
        } else if (responseCallback != null) {
            responseCallback.onCall(new SDKResponse(new RespVoidResult()));
        }
        if (sDKParsable instanceof SDKPoolObject) {
            ((SDKPoolObject) sDKParsable).recycle();
        }
        return z;
    }

    public void registerCallback(Class<?> cls, LibMcuCallback libMcuCallback) {
        Iterator<IExtendCallbackRegister> it = this.mExpandCallbackRegisters.iterator();
        while (it.hasNext()) {
            it.next().registerCallback(cls, libMcuCallback);
        }
        if (isSDKServiceNotExist() || libMcuCallback == null) {
            return;
        }
        this.mEventCallbackMaps.put(cls, libMcuCallback);
        if (this.mSDKService != null) {
            try {
                SDKEventType sDKEventType = new SDKEventType();
                sDKEventType.setEventType(cls.getName());
                this.mSDKService.registerCallback(this.mToken, ParseUtil.encodeJSON(sDKEventType), libMcuCallback);
                return;
            } catch (RemoteException e2) {
                Log.e(TAG, e2.getMessage(), e2);
                return;
            }
        }
        this.mIsRegisterAgainNecessary = true;
        StringBuilder sbB = a.B("SDKService not found! \n[");
        sbB.append(this.mContext.getPackageName());
        sbB.append("]");
        Log.e(TAG, sbB.toString());
        Log.e(TAG, "[register] " + cls.getSimpleName());
    }

    public void removeExpandCallbackRegister(IExtendCallbackRegister iExtendCallbackRegister) {
        this.mExpandCallbackRegisters.remove(iExtendCallbackRegister);
    }

    public SDKResponse sendCommand(SDKParsable sDKParsable) {
        SDKResponse sDKResponse = null;
        if (this.mContext == null) {
            Log.e(TAG, Log.getStackTraceString(new SDKNotConnectedException()));
        } else if (!isSDKServiceNotExist()) {
            if (this.mSDKService != null) {
                try {
                    SDKRequest sDKRequestPopRequest = popRequest();
                    sDKRequestPopRequest.setRequestName(ParseUtil.getClassName(sDKParsable));
                    sDKRequestPopRequest.setParamsJson(ParseUtil.encodeJSON(sDKParsable));
                    String strEncodeJSON = ParseUtil.encodeJSON(sDKRequestPopRequest);
                    pushRequest(sDKRequestPopRequest);
                    sDKResponse = (SDKResponse) ParseUtil.decodeJSON(this.mSDKService.sendMessage(this.mToken, strEncodeJSON), SDKResponse.class);
                } catch (RemoteException e2) {
                    Log.e(TAG, e2.getMessage(), e2);
                }
            } else {
                StringBuilder sbB = a.B("SDKService not found! \n[");
                sbB.append(this.mContext.getPackageName());
                sbB.append("]");
                Log.e(TAG, sbB.toString());
                Log.e(TAG, "[sendCommand] " + sDKParsable.getClass().getSimpleName());
                sDKResponse = new SDKResponse(SDKResponse.Status.SERVICE_NOT_FOUND);
            }
        }
        if (sDKParsable instanceof SDKPoolObject) {
            ((SDKPoolObject) sDKParsable).recycle();
        }
        return sDKResponse == null ? new SDKResponse(SDKResponse.Status.SDK_NOT_CONNECTED) : sDKResponse;
    }

    public void unregisterCallback(Class<?> cls, LibMcuCallback libMcuCallback) {
        Iterator<IExtendCallbackRegister> it = this.mExpandCallbackRegisters.iterator();
        while (it.hasNext()) {
            it.next().unregisterCallback(cls, libMcuCallback);
        }
        if (isSDKServiceNotExist() || libMcuCallback == null) {
            return;
        }
        this.mEventCallbackMaps.remove(cls);
        if (this.mSDKService != null) {
            try {
                SDKEventType sDKEventType = new SDKEventType();
                sDKEventType.setEventType(cls.getName());
                this.mSDKService.unregisterCallback(this.mToken, ParseUtil.encodeJSON(sDKEventType), libMcuCallback);
                return;
            } catch (RemoteException e2) {
                Log.e(TAG, e2.getMessage(), e2);
                return;
            }
        }
        StringBuilder sbB = a.B("SDKService not found! \n[");
        sbB.append(this.mContext.getPackageName());
        sbB.append("]");
        Log.e(TAG, sbB.toString());
        Log.e(TAG, "[unregister] " + cls.getSimpleName());
    }

    private OpenSDK() {
        this.mRequestPool = new LinkedList<>();
        this.mEventCallbackMaps = new HashMap();
        this.mOnSdkConnected = new ConcurrentLinkedQueue<>();
        this.mIsRegisterAgainNecessary = false;
        this.mUserId = b.f3600b;
        this.mExpandCallbackRegisters = new CopyOnWriteArrayList();
        this.mHandler = new Handler(Looper.getMainLooper()) { // from class: com.seewo.sdk.OpenSDK.1
            @Override // android.os.Handler
            public void handleMessage(Message message) {
                int i2 = message.what;
                if (i2 == 1001) {
                    RLog.w(OpenSDK.TAG, "SDKService reconnecting...");
                    if (OpenSDK.this.innerConnect()) {
                        return;
                    }
                    RLog.e(OpenSDK.TAG, "SDKService connecting fail!");
                    OpenSDK.this.startSDKService();
                    OpenSDK.this.mHandler.sendEmptyMessageDelayed(1001, 1000L);
                    return;
                }
                if (i2 != OpenSDK.ACTION_CONNECTED) {
                    return;
                }
                OpenSDK.this.mHandler.removeMessages(1001);
                RLog.i(OpenSDK.TAG, "SDKService connected!");
                if (OpenSDK.this.mIsRegisterAgainNecessary) {
                    OpenSDK.this.registerCallbacksAgain();
                    OpenSDK.this.mIsRegisterAgainNecessary = false;
                }
                while (true) {
                    OnSdkConnected onSdkConnected = (OnSdkConnected) OpenSDK.this.mOnSdkConnected.poll();
                    if (onSdkConnected == null) {
                        return;
                    } else {
                        onSdkConnected.onSdkConnected();
                    }
                }
            }
        };
        this.mDeathRecipient = new IBinder.DeathRecipient() { // from class: com.seewo.sdk.OpenSDK.2
            @Override // android.os.IBinder.DeathRecipient
            public void binderDied() {
                RLog.e(OpenSDK.TAG, "SDKService connection interrupt!");
                OpenSDK.this.processWhenDisconnected();
                OpenSDK.this.mIsRegisterAgainNecessary = true;
                OpenSDK.this.mHandler.sendEmptyMessage(1001);
            }
        };
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void connect(Context context, OnSdkConnected onSdkConnected) {
        this.mContext = context.getApplicationContext();
        if (isSDKServiceNotExist()) {
            if (onSdkConnected != null) {
                onSdkConnected.onSdkConnected();
            }
        } else {
            SDKServiceManager.i().init(this.mContext);
            addSDKConnectedCallback(onSdkConnected);
            if (innerConnect()) {
                return;
            }
            this.mHandler.sendEmptyMessage(1001);
        }
    }

    @Override // com.seewo.sdk.interfaces.IOpenSDK
    public void connectAsUser(Context context, OnSdkConnected onSdkConnected, UserHandle userHandle) {
        this.mContext = context.getApplicationContext();
        UserHandle userHandle2 = b.a;
        this.mUserId = UserHandle.myUserId();
        if (isSDKServiceNotExist()) {
            if (onSdkConnected != null) {
                onSdkConnected.onSdkConnected();
            }
        } else {
            SDKServiceManager.i().init(this.mContext);
            addSDKConnectedCallback(onSdkConnected);
            if (innerConnect()) {
                return;
            }
            this.mHandler.sendEmptyMessage(1001);
        }
    }
}