package com.cvte.dss.ups.camera;

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;
import com.cvte.dss.ups.camera.model.UpgradeResult;
import com.cvte.dss.ups.camera.utils.CameraHelper;
import com.cvte.dss.ups.camera.utils.CommonUtils;
import com.cvte.dss.ups.plugin.IUpsPlugin;
import com.cvte.vman.VmanMiddleWare;
import d.b.a.a.a;
import g.h0.c.g;
import g.h0.c.l;
import g.h0.c.x;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;

/* JADX INFO: compiled from: CameraManager.kt */
/* JADX INFO: loaded from: classes.dex */
public final class CameraManager {
    private static final byte CAMERA_MAIN_START_UPGRADE = 34;
    private static final byte CAMERA_SUB_CODE_GET_OTA_BACK = 15;
    private static final byte CAMERA_SUB_CODE_GET_OTA_KEY = 14;
    private static final byte CAMERA_SUB_CODE_GET_VERSION = 6;
    private static final byte CAMERA_SUB_CODE_GET_VERSION_BACK = 7;
    private static final byte CAMERA_SUB_START_UPGRADE = 0;
    private static final byte CAMERA_SUB_UPLOAD_FINISH = 2;
    private static final int COMMAND_DATA_BEGIN_INDEX = 7;
    public static final Companion Companion = new Companion(null);
    private static final int HID_UPLOAD_DATA = 510;
    private static final int MAX_TRY_COUNT = 3;
    public static final int NORMAL_TRY_SLEEP_TIME = 500;
    private static final String TAG = "CameraServiceCore";
    public static final String TEMP_CAMERA_FILE_DIR = "/sdcard/tmp/";
    private static final int TIME_SECOND_CAMERA_REBOOT_FINISH = 16;
    private static final long TIME_SECOND_CAMERA_REBOOT_FINISH_INTERNAL = 1000;
    private final CameraHdiApi cameraHdiApi;
    private Context context;
    private Handler mHandler;

    /* JADX INFO: compiled from: CameraManager.kt */
    public static final class Companion {
        private Companion() {
        }

        public /* synthetic */ Companion(g gVar) {
            this();
        }
    }

    public CameraManager(CameraHdiApi cameraHdiApi) {
        l.g(cameraHdiApi, "cameraHdiApi");
        this.cameraHdiApi = cameraHdiApi;
        this.mHandler = new Handler(Looper.getMainLooper());
    }

    private final void checkCameraVersion(float f2, IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) {
        Object objL;
        CommonUtils.INSTANCE.safeSleep(10000);
        for (int i2 = 0; i2 < 10; i2++) {
            Plugin plugin = new Plugin();
            Context context = this.context;
            if (context == null) {
                l.l();
                throw null;
            }
            IUpsPlugin.FirmwareInfo firmwareInfo = plugin.getFirmwareInfo(context);
            String version = firmwareInfo != null ? firmwareInfo.getVersion() : null;
            if (!a.b0("checkCameraVersion: ", version, TAG, version)) {
                iUpgradeStatusListener.onProcess(1.0f);
                iUpgradeStatusListener.onComplete();
                try {
                    VmanMiddleWare vmanMiddleWare = VmanMiddleWare.getInstance();
                    l.b(vmanMiddleWare, "VmanMiddleWare.getInstance()");
                    objL = Integer.valueOf(Log.i(TAG, "setCameraStatusUpdate: result = " + vmanMiddleWare.getAvManager().setCameraStatusUpdate(true)));
                } catch (Throwable th) {
                    objL = f.a.y.a.L(th);
                }
                if (g.l.a(objL) != null) {
                    Log.e(TAG, "setCameraStatusUpdate error");
                    return;
                }
                return;
            }
            CommonUtils.INSTANCE.safeSleep(7000);
            if (((double) f2) + 0.1d < 0.99d) {
                f2 += 0.1f;
            }
            iUpgradeStatusListener.onProcess(f2);
        }
        iUpgradeStatusListener.onFailed(" checkCameraVersion fail");
    }

    private final byte[] checkSum(byte b2) {
        return this.cameraHdiApi.sendCameraCommand((byte) 34, (byte) 2, new byte[]{b2});
    }

    private final void deleteTempFile(String str) {
        Log.e(TAG, "deleteTempFile path = " + str);
        File file = new File(str);
        if (file.exists()) {
            file.delete();
        }
    }

    private final void finishUpgradeCamera(String str) {
        deleteTempFile(str);
        CameraHelper.INSTANCE.removeUpgradingCamera(this.cameraHdiApi.getCameraInfo());
    }

    private final float startReadFileProgress(float f2, final IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) {
        final x xVar = new x();
        xVar.f4110b = f2;
        this.mHandler.postDelayed(new Runnable() { // from class: com.cvte.dss.ups.camera.CameraManager.startReadFileProgress.1
            @Override // java.lang.Runnable
            public void run() {
                x xVar2 = xVar;
                float f3 = xVar2.f4110b;
                if (((double) f3) + 0.001d < 0.5f) {
                    float f4 = f3 + 0.001f;
                    xVar2.f4110b = f4;
                    iUpgradeStatusListener.onProcess(f4);
                }
                CameraManager.this.getMHandler().postDelayed(this, 2000L);
            }
        }, 2000L);
        return xVar.f4110b;
    }

    private final boolean startUploadFile(String str, IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener) throws IOException {
        File file = new File(str);
        if (!file.exists()) {
            Log.i(TAG, "startUploadFile: file not exist");
            if (iUpgradeStatusListener != null) {
                iUpgradeStatusListener.onFailed("file not exist!");
            }
            return false;
        }
        FileInputStream fileInputStream = new FileInputStream(file);
        byte[] bArr = new byte[HID_UPLOAD_DATA];
        this.cameraHdiApi.connect();
        byte b2 = 0;
        while (true) {
            try {
                try {
                    if (fileInputStream.read(bArr) == -1) {
                        break;
                    }
                    this.cameraHdiApi.startUpgradeDataTransfer(bArr);
                    for (int i2 = 0; i2 < HID_UPLOAD_DATA; i2++) {
                        b2 = (byte) (b2 + bArr[i2]);
                    }
                    l.f(bArr, "<this>");
                    Arrays.fill(bArr, 0, HID_UPLOAD_DATA, (byte) 0);
                } catch (Exception e2) {
                    Log.i(TAG, "startUploadFile: ", e2);
                    if (iUpgradeStatusListener != null) {
                        iUpgradeStatusListener.onFailed("startUploadFile fail");
                    }
                }
            } finally {
                fileInputStream.close();
                this.mHandler.removeCallbacksAndMessages(null);
                this.cameraHdiApi.disconnect();
            }
        }
        byte[] bArrCheckSum = checkSum(b2);
        if (bArrCheckSum != null && bArrCheckSum[7] == 0) {
            return true;
        }
        if (iUpgradeStatusListener == null) {
            return false;
        }
        iUpgradeStatusListener.onFailed("check sum fail");
        return false;
    }

    public final Handler getMHandler() {
        return this.mHandler;
    }

    public final String getOTAKey() {
        int i2 = 0;
        String cameraMessage = "";
        while (TextUtils.isEmpty(cameraMessage) && i2 < 3) {
            i2++;
            cameraMessage = this.cameraHdiApi.getCameraMessage((byte) 14, (byte) 15);
            CommonUtils.INSTANCE.safeSleep(500);
        }
        a.N(" getVersion ota key", cameraMessage, TAG);
        return cameraMessage != null ? cameraMessage : "";
    }

    public final String getVersion() {
        String cameraMessage = this.cameraHdiApi.getCameraMessage((byte) 6, (byte) 7);
        int i2 = 0;
        while (TextUtils.isEmpty(cameraMessage) && i2 < 3) {
            i2++;
            cameraMessage = this.cameraHdiApi.getCameraMessage((byte) 6, (byte) 7);
            CommonUtils.INSTANCE.safeSleep(500);
        }
        a.N(" getVersion version=", cameraMessage, TAG);
        return cameraMessage != null ? cameraMessage : "";
    }

    public final void setMHandler(Handler handler) {
        l.g(handler, "<set-?>");
        this.mHandler = handler;
    }

    public final void upgradeCamera(String str, IUpsPlugin.IUpgradeStatusListener iUpgradeStatusListener, Context context) {
        l.g(str, "path");
        l.g(iUpgradeStatusListener, "listener");
        l.g(context, "context");
        CameraHelper.INSTANCE.addUpgradingCamera(this.cameraHdiApi.getCameraInfo());
        long length = new File(str).length();
        int i2 = (int) length;
        if (i2 == -1) {
            iUpgradeStatusListener.onFailed("file length is -1");
            finishUpgradeCamera(str);
            return;
        }
        this.context = context;
        Log.i(TAG, "upgradeCamera:length " + length + "upgradeCamera:path" + str);
        byte[] bArrSendCameraCommand = this.cameraHdiApi.sendCameraCommand((byte) 34, (byte) 0, CommonUtils.INSTANCE.changeFileLengthToByteArray(i2));
        if (bArrSendCameraCommand == null || bArrSendCameraCommand[7] != 0) {
            iUpgradeStatusListener.onFailed("check file fail");
            finishUpgradeCamera(str);
            return;
        }
        Log.i(TAG, "upgradeCamera:发送完文件长度 开始升级，收到升级回复");
        iUpgradeStatusListener.onProcess(0.1f);
        startReadFileProgress(0.1f, iUpgradeStatusListener);
        if (!startUploadFile(str, iUpgradeStatusListener)) {
            Log.i(TAG, "upload file fail");
            finishUpgradeCamera(str);
            iUpgradeStatusListener.onFailed("upload file fail");
            this.cameraHdiApi.disconnect();
            return;
        }
        Log.i(TAG, "upload file success");
        float upgradeProgress = 0.0f;
        float f2 = 0.5f;
        while (true) {
            float f3 = 0;
            if (upgradeProgress < f3 || upgradeProgress >= 100) {
                break;
            }
            upgradeProgress = this.cameraHdiApi.getUpgradeProgress();
            Log.i(TAG, "upgradeCamera: " + upgradeProgress);
            if (upgradeProgress > f3) {
                f2 = (upgradeProgress / 400) + 0.5f;
                iUpgradeStatusListener.onProcess(f2);
            }
        }
        this.cameraHdiApi.disconnect();
        for (int i3 = 0; i3 < 16; i3++) {
            CommonUtils.INSTANCE.safeSleep(TIME_SECOND_CAMERA_REBOOT_FINISH_INTERNAL);
            f2 += 0.01f;
            iUpgradeStatusListener.onProcess(f2);
        }
        Log.i(TAG, "upgradeCamera: finish");
        checkCameraVersion(f2, iUpgradeStatusListener);
        finishUpgradeCamera(str);
    }

    public final UpgradeResult upgradeCamera(String str) {
        l.g(str, "path");
        CameraHelper.INSTANCE.addUpgradingCamera(this.cameraHdiApi.getCameraInfo());
        long length = new File(str).length();
        int i2 = (int) length;
        if (i2 == -1) {
            return new UpgradeResult(false, "file length is -1");
        }
        CommonUtils commonUtils = CommonUtils.INSTANCE;
        String strCopyFileToTemp = commonUtils.copyFileToTemp(str, TEMP_CAMERA_FILE_DIR);
        Log.i(TAG, "upgradeCamera:length " + length + "upgradeCamera:path" + str);
        byte[] bArrSendCameraCommand = this.cameraHdiApi.sendCameraCommand((byte) 34, (byte) 0, commonUtils.changeFileLengthToByteArray(i2));
        if (bArrSendCameraCommand != null && bArrSendCameraCommand[7] == 0) {
            Log.i(TAG, "upgradeCamera:发送完文件长度 开始升级，收到升级回复");
            if (!startUploadFile(strCopyFileToTemp, null)) {
                Log.i(TAG, "upload file fail");
                deleteTempFile(strCopyFileToTemp);
                this.cameraHdiApi.disconnect();
                return new UpgradeResult(false, "upload file fail");
            }
            Log.i(TAG, "upload file success");
            float upgradeProgress = 0.0f;
            while (upgradeProgress >= 0 && upgradeProgress < 100) {
                upgradeProgress = this.cameraHdiApi.getUpgradeProgress();
                Log.i(TAG, "upgradeCamera: " + upgradeProgress);
            }
            this.cameraHdiApi.disconnect();
            for (int i3 = 0; i3 < 16; i3++) {
                CommonUtils.INSTANCE.safeSleep(TIME_SECOND_CAMERA_REBOOT_FINISH_INTERNAL);
            }
            deleteTempFile(strCopyFileToTemp);
            Log.i(TAG, "upgradeCamera: finish");
            return new UpgradeResult(true, null, 2, null);
        }
        deleteTempFile(strCopyFileToTemp);
        return new UpgradeResult(false, "check file fail");
    }
}