package com.cvte.vman.client;

import android.os.IBinder;
import android.os.Parcel;
import android.os.Process;
import android.os.RemoteException;
import android.os.ServiceManager;
import com.cvte.vman.VmanMiddleWare;
import com.cvte.vman.data.CacheMechanism;
import com.cvte.vman.utils.CLog;
import vendor.cvte.hwvman.IAHwVman;
import vendor.cvte.hwvman.IAHwVmanCallback;

/* JADX INFO: loaded from: classes.dex */
public class VmanAidlClient extends CacheMechanism {
    private static final String HAL_AIDL_INSTANCE_NAME = IAHwVman.DESCRIPTOR + "/default";
    private static VmanAidlClient mVmanAidlClient = null;
    private static IAHwVman mAHwVman = null;
    private static VmanHardwareCallback mIHwVmanCallback = new VmanHardwareCallback();

    private static class VmanHardwareCallback extends IAHwVmanCallback.Stub implements IBinder.DeathRecipient {
        private VmanHardwareCallback() {
        }

        @Override // android.os.IBinder.DeathRecipient
        public void binderDied() {
            VmanAidlClient.reConnectToHwVman();
            CLog.d("AHwVman Service DeathRecipient and reconnect .");
        }

        @Override // vendor.cvte.hwvman.IAHwVmanCallback
        public String getInterfaceHash() {
            return "1a075ef00f1bd88c856cbc05bb4f109feb7873a5";
        }

        @Override // vendor.cvte.hwvman.IAHwVmanCallback
        public int getInterfaceVersion() {
            return 1;
        }

        @Override // vendor.cvte.hwvman.IAHwVmanCallback
        public void hwNotify(int i2, int i3, byte[] bArr) throws RemoteException {
            if (VmanMiddleWare.getInstance().mEventHandler == null) {
                CLog.e("hwNotify: mEventHandler is null");
                return;
            }
            Parcel parcelObtain = Parcel.obtain();
            Parcel parcelObtain2 = Parcel.obtain();
            parcelObtain2.writeByteArray(bArr);
            parcelObtain2.setDataPosition(4);
            parcelObtain.appendFrom(parcelObtain2, parcelObtain2.dataPosition(), parcelObtain2.dataAvail());
            parcelObtain.setDataPosition(0);
            VmanMiddleWare.getInstance().mEventHandler.sendMessage(VmanMiddleWare.getInstance().mEventHandler.obtainMessage(i2, 0, 0, parcelObtain));
            CLog.i("hwNotify: sendMessage type=" + i2);
        }
    }

    private VmanAidlClient() {
    }

    public static int VmanInvoke(Parcel parcel, Parcel parcel2) {
        if (mAHwVman == null && !reConnectToHwVman()) {
            CLog.e("VmanInvoke reConnectToHwVman error!!!");
            return -1;
        }
        Parcel parcelObtain = Parcel.obtain();
        try {
            parcelObtain.writeByteArray(mAHwVman.hwInvoke(parcel.marshall()));
            parcelObtain.setDataPosition(4);
            parcel2.appendFrom(parcelObtain, parcelObtain.dataPosition(), parcelObtain.dataAvail());
            parcel2.setDataPosition(0);
            int i2 = parcel2.readInt();
            parcel2.setDataPosition(0);
            parcelObtain.recycle();
            return i2;
        } catch (RemoteException unused) {
            CLog.w("RemoteException: try to reconnect");
            reConnectToHwVman();
            parcelObtain.recycle();
            return -1;
        }
    }

    public static boolean connectToHwVman() {
        getHwVmanService();
        if (mAHwVman == null) {
            return false;
        }
        try {
            CacheMechanism.initCacheMechanism();
            mAHwVman.init();
            mAHwVman.hwRegistCallback(mIHwVmanCallback, Process.myPid());
            mAHwVman.asBinder().linkToDeath(mIHwVmanCallback, Process.myPid());
            return true;
        } catch (RemoteException e) {
            e.printStackTrace();
            return false;
        }
    }

    public static IAHwVman getHwVmanService() {
        if (mAHwVman == null) {
            try {
                mAHwVman = IAHwVman.Stub.asInterface(ServiceManager.waitForDeclaredService(HAL_AIDL_INSTANCE_NAME));
            } catch (Exception e) {
                CLog.e("Unable to get IAHwVman service, " + e);
                return null;
            }
        }
        return mAHwVman;
    }

    public static synchronized VmanAidlClient getInstance() {
        if (mVmanAidlClient == null) {
            mVmanAidlClient = new VmanAidlClient();
        }
        return mVmanAidlClient;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean reConnectToHwVman() {
        mAHwVman = null;
        return connectToHwVman();
    }

    public boolean isVmanReady() {
        try {
            return IAHwVman.Stub.asInterface(ServiceManager.waitForDeclaredService(HAL_AIDL_INSTANCE_NAME)) != null;
        } catch (Exception e) {
            CLog.e("IAHwVman service no ready " + e);
            return false;
        }
    }
}