package com.cvte.vman.client;

import android.os.IHwBinder;
import android.os.Parcel;
import android.os.Process;
import android.os.RemoteException;
import com.cvte.vman.VmanMiddleWare;
import com.cvte.vman.data.CacheMechanism;
import com.cvte.vman.utils.CLog;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import vendor.cvte.hwvman.V1_0.IHwVman;
import vendor.cvte.hwvman.V1_0.IHwVmanCallback;

/* JADX INFO: loaded from: classes.dex */
public class VmanHidlClient extends CacheMechanism {
    private static IHwVman mHwVman;
    private static VmanHardwareCallback mIHwVmanCallback = new VmanHardwareCallback();
    private static VmanHidlClient mVmanHidlClient;

    private static class VmanHardwareCallback extends IHwVmanCallback.Stub implements IHwBinder.DeathRecipient {
        private VmanHardwareCallback() {
        }

        @Override // vendor.cvte.hwvman.V1_0.IHwVmanCallback
        public void hwNotify(int i2, int i3, String str) throws RemoteException {
        }

        @Override // vendor.cvte.hwvman.V1_0.IHwVmanCallback
        public void hwNotify_vec(int i2, int i3, ArrayList<Byte> arrayList) throws RemoteException {
            if (VmanMiddleWare.getInstance().mEventHandler == null) {
                CLog.e("hwNotify_vec: mEventHandler is null");
                return;
            }
            Parcel parcelObtain = Parcel.obtain();
            Parcel parcelObtain2 = Parcel.obtain();
            byte[] bArr = new byte[arrayList.size()];
            for (int i4 = 0; i4 < arrayList.size(); i4++) {
                bArr[i4] = arrayList.get(i4).byteValue();
            }
            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_vec: sendMessage type=" + i2);
        }

        @Override // android.os.IHwBinder.DeathRecipient
        public void serviceDied(long j2) {
            VmanHidlClient.reConnectToHwVman();
            CLog.d("IHwVman Service DeathRecipient and reconnect .");
        }
    }

    private VmanHidlClient() {
    }

    public static int VmanInvoke(Parcel parcel, Parcel parcel2) {
        if (mHwVman == null && !reConnectToHwVman()) {
            CLog.e("VmanInvoke reConnectToHwVman error!!!");
            return -1;
        }
        Parcel parcelObtain = Parcel.obtain();
        new ArrayList();
        byte[] bArrMarshall = parcel.marshall();
        ArrayList<Byte> arrayList = new ArrayList<>(bArrMarshall.length);
        for (byte b : bArrMarshall) {
            arrayList.add(Byte.valueOf(b));
        }
        try {
            ArrayList<Byte> arrayListHwInvoke_vec = mHwVman.hwInvoke_vec(arrayList);
            byte[] bArr = new byte[arrayListHwInvoke_vec.size()];
            for (int i2 = 0; i2 < arrayListHwInvoke_vec.size(); i2++) {
                bArr[i2] = arrayListHwInvoke_vec.get(i2).byteValue();
            }
            parcelObtain.writeByteArray(bArr);
            parcelObtain.setDataPosition(4);
            parcel2.appendFrom(parcelObtain, parcelObtain.dataPosition(), parcelObtain.dataAvail());
            parcel2.setDataPosition(0);
            int i3 = parcel2.readInt();
            parcel2.setDataPosition(0);
            parcelObtain.recycle();
            return i3;
        } catch (RemoteException e) {
            e.printStackTrace();
            CLog.w("RemoteException: try to reconnect");
            reConnectToHwVman();
            parcelObtain.recycle();
            return -1;
        }
    }

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

    public static IHwVman getHwVmanService() {
        if (mHwVman == null) {
            try {
                mHwVman = IHwVman.getService();
            } catch (RemoteException e) {
                e.printStackTrace();
                return null;
            } catch (NoSuchElementException e2) {
                e2.printStackTrace();
                return null;
            } catch (Exception e3) {
                e3.printStackTrace();
                return null;
            }
        }
        return mHwVman;
    }

    public static synchronized VmanHidlClient getInstance() {
        if (mVmanHidlClient == null) {
            mVmanHidlClient = new VmanHidlClient();
        }
        return mVmanHidlClient;
    }

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

    public boolean isVmanReady() {
        try {
            return IHwVman.getService() != null;
        } catch (RemoteException e) {
            e.printStackTrace();
            return false;
        } catch (NoSuchElementException e2) {
            e2.printStackTrace();
            return false;
        } catch (Exception e3) {
            e3.printStackTrace();
            return false;
        }
    }
}