package com.ifpdos.factorytest.mic.tester;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.ifpdos.factorytest.R;
import com.ifpdos.factorytest.mic.IUdiMicAirContract;
import com.ifpdos.factorytest.mic.MicAirHandler;
import com.ifpdos.factorytest.mic.hid.CommStatus;
import com.ifpdos.factorytest.mic.hid.DeviceUtils;
import com.ifpdos.factorytest.mic.hid.HardwareStatus;
import com.ifpdos.factorytest.mic.hid.MicArrayCommApi;
import com.ifpdos.factorytest.udi.MicAirDbBody;
import com.ifpdos.factorytest.udi.MicAirDbListBody;
import com.ifpdos.factorytest.udi.ProtocolDefineKt;
import java.util.ArrayList;

/* JADX INFO: loaded from: classes.dex */
public class MicAirTestActivity extends Activity implements IUdiMicAirContract {
    private static final String MIC_HW_DSP_VERSION = "mic.hw.dsp.version";
    private static final int MIC_HW_RET_TESTING_MASK = Integer.MIN_VALUE;
    private static final String MIC_HW_TEST_AMP_PROP_NAME = "mic.hw.test.amp";
    private static final String MIC_HW_TEST_CHNUM_PROP_NAME = "mic.hw.test.chnum";
    private static final String MIC_HW_TEST_REQ_PROP_NAME = "mic.hw.test.req";
    private static final String MIC_HW_TEST_RET_PROP_NAME = "mic.hw.test.ret";
    private static final String MIC_HW_TEST_TESTING = "testing";
    private static final int MSG_SIZE_CHANGE = 1005;
    private static final int MSG_UPDATE_HW_STATUS = 1000;
    private static final String TAG = "CvteMicArrayFactoryTest";
    private static final int UPDATE_PERIOD_MS = 10;
    boolean mBlinkFlag;
    int mCntLineins;
    int mCntMics;
    int mCntRefs;
    Handler mHandler = new Handler() { // from class: com.ifpdos.factorytest.mic.tester.MicAirTestActivity.1
        @Override // android.os.Handler
        public void handleMessage(Message message) {
            int i = message.what;
            if (i != 1000) {
                if (i != 1005) {
                    return;
                }
                MicAirTestActivity.this.onSizeChanged(message.arg1, message.arg2);
                return;
            }
            MicAirTestActivity.this.mLastUpdateTime = System.currentTimeMillis();
            if (MicAirTestActivity.this.updateHwStatus()) {
                MicAirTestActivity micAirTestActivity = MicAirTestActivity.this;
                micAirTestActivity.CheckChsError(micAirTestActivity.mMicSigView, MicAirTestActivity.this.mCntMics);
                MicAirTestActivity micAirTestActivity2 = MicAirTestActivity.this;
                micAirTestActivity2.CheckChsError(micAirTestActivity2.mRefSigView, MicAirTestActivity.this.mCntRefs);
                if (MicAirTestActivity.this.mCntLineins > 0) {
                    MicAirTestActivity micAirTestActivity3 = MicAirTestActivity.this;
                    micAirTestActivity3.CheckChsError(micAirTestActivity3.mLineinSigView, MicAirTestActivity.this.mCntLineins);
                }
                MicAirTestActivity.this.CheckAllChsOk();
            }
            long jCurrentTimeMillis = 10 - (System.currentTimeMillis() - MicAirTestActivity.this.mLastUpdateTime);
            if (jCurrentTimeMillis < 0) {
                jCurrentTimeMillis = 0;
            }
            sendEmptyMessageDelayed(1000, jCurrentTimeMillis);
        }
    };
    HardwareStatus mHardwareStatus;
    private boolean mIsFromUdi;
    long mLastBlinkTime;
    long mLastUpdateTime;
    LinearLayout mLedArea;
    int mLineinIndex;
    ChSignalView[] mLineinSigView;
    MicArrayCommApi mMicArrayCommApi;
    int mMicHwTestStatLast;
    ChSignalView[] mMicSigView;
    boolean mMicTestingGot;
    RecorderThread mRecorderThread;
    int mRefIndex;
    ChSignalView[] mRefSigView;
    Button mResetBt;
    LinearLayout mRoot;
    TextView mStatusView;
    boolean mTestReqToggle;
    boolean mUseExtDsp;
    TextView mVersionView;
    int mWaitCount;

    void CheckChsError(ChSignalView[] chSignalViewArr, int i) {
        double dbLevle = 0.0d;
        for (int i2 = 0; i2 < i; i2++) {
            dbLevle += chSignalViewArr[i2].getDbLevle();
        }
        double d = dbLevle / ((double) i);
        for (int i3 = 0; i3 < i; i3++) {
            double dbLevle2 = chSignalViewArr[i3].getDbLevle();
            if (Math.abs(dbLevle2 - d) > 2.0f || chSignalViewArr[i3].mErrorCnt == 100) {
                if (chSignalViewArr[i3].mErrorCnt < 200) {
                    chSignalViewArr[i3].mErrorCnt++;
                }
                if (chSignalViewArr[i3].mErrorCnt > 3) {
                    chSignalViewArr[i3].setTestRet(2);
                }
            } else {
                chSignalViewArr[i3].mErrorCnt = 0;
            }
            if (chSignalViewArr[i3].mErrorCnt == 0) {
                if (dbLevle2 < -40.0d) {
                    chSignalViewArr[i3].setTestRet(2);
                } else if (dbLevle2 > -30.0d) {
                    chSignalViewArr[i3].setTestRet(1);
                }
            }
        }
    }

    boolean isUseBuildInMic() {
        for (int i = 0; i < 5; i++) {
            if (SystemProp.get(MIC_HW_TEST_REQ_PROP_NAME, "").isEmpty()) {
                return true;
            }
            try {
                Thread.sleep(10L);
            } catch (Exception unused) {
            }
        }
        return false;
    }

    void CheckAllChsOk() {
        for (int i = 0; i < this.mCntMics; i++) {
            if (this.mMicSigView[i].mOkCnt < 5) {
                return;
            }
        }
        for (int i2 = 0; i2 < this.mCntRefs; i2++) {
            if (this.mRefSigView[i2].mOkCnt < 5) {
                return;
            }
        }
        for (int i3 = 0; i3 < this.mCntLineins; i3++) {
            if (this.mLineinSigView[i3].mOkCnt < 5) {
                return;
            }
        }
        this.mStatusView.setText(getString(R.string.congratulations_all_channels_passed));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onSizeChanged(int i, int i2) {
        int i3 = this.mCntMics + this.mCntRefs + this.mCntLineins;
        int width = i - this.mResetBt.getWidth();
        for (int i4 = 0; i4 < HardwareStatus.MIC_CHS; i4++) {
            this.mMicSigView[i4].onSizeChanged(width, i2, i3);
            this.mMicSigView[i4].setTitle(getString(R.string.mic_channel) + i4);
        }
        for (int i5 = 0; i5 < HardwareStatus.REF_CHS; i5++) {
            this.mRefSigView[i5].onSizeChanged(width, i2, i3);
            this.mRefSigView[i5].setTitle(getString(R.string.ref_channel) + i5);
        }
        for (int i6 = 0; i6 < HardwareStatus.LINEIN_CHS; i6++) {
            this.mLineinSigView[i6].onSizeChanged(width, i2, i3);
            this.mLineinSigView[i6].setTitle(getString(R.string.line_input) + i6);
        }
    }

    boolean updateHwTestRet() {
        int i;
        if (this.mHardwareStatus.micHwTestStat == HardwareStatus.MIC_HW_RET_TESTING_MASK) {
            this.mMicTestingGot = true;
        } else {
            this.mMicHwTestStatLast = this.mHardwareStatus.micHwTestStat;
            if (this.mUseExtDsp) {
                this.mMicArrayCommApi.requestMicStartHwTest();
            }
            this.mMicTestingGot = false;
        }
        if (this.mHardwareStatus.calAmpCnt != 0) {
            return false;
        }
        if (this.mMicTestingGot && (i = this.mCntMics) > 0 && i <= HardwareStatus.MIC_CHS) {
            for (int i2 = 0; i2 < i; i2++) {
                if ((this.mMicHwTestStatLast & (1 << ((i - 1) - i2))) == 0) {
                    float f = this.mBlinkFlag ? 0.120000005f : 0.02f;
                    float[] fArr = this.mHardwareStatus.adcAmpAbsSum;
                    fArr[i2] = fArr[i2] * f;
                    float[] fArr2 = this.mHardwareStatus.adcAmpSum;
                    fArr2[i2] = fArr2[i2] * f;
                    float[] fArr3 = this.mHardwareStatus.adcAmpAbsAvg;
                    fArr3[i2] = fArr3[i2] * f;
                    float[] fArr4 = this.mHardwareStatus.adcAmpAvg;
                    fArr4[i2] = fArr4[i2] * f;
                    this.mMicSigView[i2].mErrorCnt = 100;
                }
            }
        }
        if (System.currentTimeMillis() - this.mLastBlinkTime > 150) {
            this.mBlinkFlag = !this.mBlinkFlag;
            this.mLastBlinkTime = System.currentTimeMillis();
        }
        if (this.mUseExtDsp) {
            this.mMicArrayCommApi.requestMicSetAmpCnt(10);
        }
        if (this.mUseExtDsp) {
            this.mCntRefs = HardwareStatus.REF_CHS;
            this.mCntMics = this.mHardwareStatus.numChs - this.mCntRefs;
            this.mCntLineins = 0;
        } else if (this.mLineinIndex >= 0) {
            this.mCntLineins = 1;
            this.mCntRefs = 1;
            this.mCntMics = (this.mHardwareStatus.numChs - this.mCntRefs) - this.mCntLineins;
        } else {
            this.mCntLineins = 0;
            this.mCntRefs = HardwareStatus.REF_CHS;
            this.mCntMics = this.mHardwareStatus.numChs - this.mCntRefs;
        }
        if (this.mCntMics < 0) {
            this.mCntMics = 0;
        }
        if (this.mCntMics > HardwareStatus.MIC_CHS) {
            this.mCntMics = HardwareStatus.MIC_CHS;
        }
        for (int i3 = 0; i3 < this.mCntMics; i3++) {
            this.mMicSigView[i3].setSigLevel(this.mHardwareStatus.adcAmpAbsAvg[i3]);
        }
        if (this.mUseExtDsp) {
            for (int i4 = 0; i4 < this.mCntRefs; i4++) {
                this.mRefSigView[i4].setSigLevel(this.mHardwareStatus.adcAmpAbsAvg[this.mCntMics + i4]);
            }
        } else {
            if (this.mCntRefs > 1) {
                int i5 = this.mRefIndex;
                if ((i5 & 1) == 1) {
                    this.mRefIndex = i5 & (-2);
                }
            }
            for (int i6 = 0; i6 < this.mCntRefs; i6++) {
                this.mRefSigView[i6].setSigLevel(this.mHardwareStatus.adcAmpAbsAvg[this.mRefIndex + i6]);
            }
            for (int i7 = 0; i7 < this.mCntLineins; i7++) {
                this.mLineinSigView[i7].setSigLevel(this.mHardwareStatus.adcAmpAbsAvg[this.mLineinIndex + i7]);
            }
        }
        int i8 = 0;
        while (i8 < this.mCntMics) {
            this.mMicSigView[i8].setVisibility(0);
            i8++;
        }
        while (true) {
            ChSignalView[] chSignalViewArr = this.mMicSigView;
            if (i8 >= chSignalViewArr.length) {
                break;
            }
            chSignalViewArr[i8].setVisibility(8);
            i8++;
        }
        int i9 = 0;
        while (i9 < this.mCntRefs) {
            this.mRefSigView[i9].setVisibility(0);
            i9++;
        }
        while (true) {
            ChSignalView[] chSignalViewArr2 = this.mRefSigView;
            if (i9 >= chSignalViewArr2.length) {
                break;
            }
            chSignalViewArr2[i9].setVisibility(8);
            i9++;
        }
        int i10 = 0;
        while (i10 < this.mCntLineins) {
            this.mLineinSigView[i10].setVisibility(0);
            i10++;
        }
        while (true) {
            ChSignalView[] chSignalViewArr3 = this.mLineinSigView;
            if (i10 >= chSignalViewArr3.length) {
                return true;
            }
            chSignalViewArr3[i10].setVisibility(8);
            i10++;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:62:0x0147  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    boolean requestHwStatusBuiltin() {
        /*
            Method dump skipped, instruction units count: 353
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.ifpdos.factorytest.mic.tester.MicAirTestActivity.requestHwStatusBuiltin():boolean");
    }

    boolean updateHwStatus() {
        if (this.mMicArrayCommApi.requestHwStatus()) {
            this.mUseExtDsp = true;
            if (this.mVersionView.getText().toString().isEmpty()) {
                updateVersionInfo();
            }
            if (CommStatus.requestId(this.mMicArrayCommApi.mHidReadBuffer) == 3 && this.mHardwareStatus.parserFromBuffer(this.mMicArrayCommApi.mHidReadBuffer)) {
                return updateHwTestRet();
            }
        } else if (!this.mUseExtDsp) {
            if (requestHwStatusBuiltin()) {
                if (this.mVersionView.getText().toString().isEmpty()) {
                    updateVersionInfo();
                }
                if (this.mHardwareStatus.parserFromBuffer(this.mMicArrayCommApi.mHidReadBuffer)) {
                    return updateHwTestRet();
                }
            }
        } else {
            updateVersionInfo();
            return false;
        }
        return false;
    }

    void updateVersionInfoInt() {
        this.mStatusView.setText(getString(R.string.finding_device));
        this.mVersionView.setText("");
        if (this.mMicArrayCommApi.requestStatus()) {
            String str = new String(CommStatus.version(this.mMicArrayCommApi.mHidReadBuffer));
            if (str.isEmpty()) {
                return;
            }
            this.mVersionView.setText(getString(R.string.has_adsp_current_version) + str);
            this.mStatusView.setText(getString(R.string.waiting_for_test));
            this.mUseExtDsp = true;
            return;
        }
        if (isUseBuildInMic()) {
            this.mUseExtDsp = false;
            this.mVersionView.setText(getString(R.string.no_adsp_current_version) + SystemProp.get(MIC_HW_DSP_VERSION, "null"));
            this.mStatusView.setText(getString(R.string.waiting_for_test));
            return;
        }
        String deviceCommPath = DeviceUtils.getDeviceCommPath();
        if (deviceCommPath == null) {
            return;
        }
        this.mMicArrayCommApi.openDevice(deviceCommPath);
    }

    void updateVersionInfo() {
        for (int i = 0; i < 2; i++) {
            updateVersionInfoInt();
            if (this.mUseExtDsp) {
                return;
            }
        }
    }

    @Override // android.app.Activity
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        boolean booleanExtra = getIntent().getBooleanExtra(ProtocolDefineKt.KEY_FROM_UDI, false);
        this.mIsFromUdi = booleanExtra;
        if (booleanExtra) {
            MicAirHandler.INSTANCE.registerIUdiMicAirImpl(this);
        }
        LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(-1, -1);
        TextView textView = new TextView(this);
        this.mVersionView = textView;
        textView.setText(" ");
        this.mVersionView.setTextSize(20.0f);
        TextView textView2 = new TextView(this);
        this.mStatusView = textView2;
        textView2.setText(" ");
        this.mStatusView.setTextSize(20.0f);
        LinearLayout linearLayout = new LinearLayout(this);
        this.mRoot = linearLayout;
        linearLayout.setOrientation(1);
        this.mRoot.setLayoutParams(layoutParams);
        setContentView(this.mRoot);
        LinearLayout linearLayout2 = new LinearLayout(this) { // from class: com.ifpdos.factorytest.mic.tester.MicAirTestActivity.2
            @Override // android.view.View
            public void onSizeChanged(int i, int i2, int i3, int i4) {
                super.onSizeChanged(i, i2, i3, i4);
                Log.e(MicAirTestActivity.TAG, "w=" + i + ", h=" + i2);
                MicAirTestActivity.this.mHandler.sendMessageDelayed(MicAirTestActivity.this.mHandler.obtainMessage(1005, i, i2), 10L);
            }
        };
        this.mLedArea = linearLayout2;
        linearLayout2.setOrientation(0);
        this.mLedArea.setLayoutParams(layoutParams);
        this.mLedArea.setGravity(80);
        this.mCntMics = HardwareStatus.MIC_CHS;
        this.mCntRefs = HardwareStatus.REF_CHS;
        this.mMicSigView = new ChSignalView[HardwareStatus.MIC_CHS];
        this.mRefSigView = new ChSignalView[HardwareStatus.REF_CHS];
        this.mLineinSigView = new ChSignalView[HardwareStatus.LINEIN_CHS];
        this.mHardwareStatus = new HardwareStatus();
        for (int i = 0; i < HardwareStatus.MIC_CHS; i++) {
            this.mMicSigView[i] = new ChSignalView(this);
            this.mLedArea.addView(this.mMicSigView[i]);
        }
        for (int i2 = 0; i2 < HardwareStatus.REF_CHS; i2++) {
            this.mRefSigView[i2] = new ChSignalView(this);
            this.mLedArea.addView(this.mRefSigView[i2]);
        }
        for (int i3 = 0; i3 < HardwareStatus.LINEIN_CHS; i3++) {
            this.mLineinSigView[i3] = new ChSignalView(this);
            this.mLedArea.addView(this.mLineinSigView[i3]);
        }
        this.mRoot.addView(this.mVersionView);
        this.mRoot.addView(this.mStatusView);
        this.mRoot.addView(this.mLedArea);
        Button button = new Button(this);
        this.mResetBt = button;
        button.setText(getString(R.string.retest_again_ask));
        this.mResetBt.setOnClickListener(new View.OnClickListener() { // from class: com.ifpdos.factorytest.mic.tester.MicAirTestActivity.3
            @Override // android.view.View.OnClickListener
            public void onClick(View view) {
                MicAirTestActivity.this.doRetest();
                MicAirTestActivity.this.updateVersionInfo();
            }
        });
        this.mLedArea.addView(this.mResetBt);
        doRetest();
    }

    void doRetest() {
        int i = 0;
        int i2 = 0;
        while (true) {
            ChSignalView[] chSignalViewArr = this.mMicSigView;
            if (i2 >= chSignalViewArr.length) {
                break;
            }
            chSignalViewArr[i2].reset();
            i2++;
        }
        int i3 = 0;
        while (true) {
            ChSignalView[] chSignalViewArr2 = this.mRefSigView;
            if (i3 >= chSignalViewArr2.length) {
                break;
            }
            chSignalViewArr2[i3].reset();
            i3++;
        }
        while (true) {
            ChSignalView[] chSignalViewArr3 = this.mLineinSigView;
            if (i < chSignalViewArr3.length) {
                chSignalViewArr3[i].reset();
                i++;
            } else {
                this.mVersionView.setText("");
                this.mStatusView.setText(getString(R.string.waiting_for_test));
                return;
            }
        }
    }

    @Override // android.app.Activity
    protected void onStart() {
        super.onStart();
        this.mHandler.removeMessages(1000);
        MicArrayCommApi micArrayCommApi = this.mMicArrayCommApi;
        if (micArrayCommApi != null) {
            micArrayCommApi.closeDevice();
            this.mMicArrayCommApi = null;
        }
        this.mMicArrayCommApi = new MicArrayCommApi();
        this.mHandler.sendEmptyMessageDelayed(1000, 100L);
        RecorderThread recorderThread = this.mRecorderThread;
        if (recorderThread != null) {
            recorderThread.requestExit();
            this.mRecorderThread = null;
        }
        RecorderThread recorderThread2 = new RecorderThread();
        this.mRecorderThread = recorderThread2;
        recorderThread2.start();
        SystemProp.set(MIC_HW_TEST_REQ_PROP_NAME, "F10");
        doRetest();
        for (int i = 0; i < 3; i++) {
            updateVersionInfo();
            if (this.mUseExtDsp) {
                return;
            }
        }
    }

    @Override // android.app.Activity
    protected void onStop() {
        super.onStop();
        try {
            this.mHandler.removeMessages(1000);
            MicArrayCommApi micArrayCommApi = this.mMicArrayCommApi;
            if (micArrayCommApi != null) {
                micArrayCommApi.closeDevice();
                this.mMicArrayCommApi = null;
            }
        } catch (Throwable th) {
            Log.e(TAG, "throw error when on stop", th);
        }
        try {
            this.mHandler.removeMessages(1000);
            RecorderThread recorderThread = this.mRecorderThread;
            if (recorderThread != null) {
                recorderThread.requestExit();
                this.mRecorderThread = null;
            }
        } catch (Throwable th2) {
            Log.e(TAG, "throw error when on stop", th2);
        }
    }

    @Override // com.ifpdos.factorytest.mic.IUdiMicAirContract
    public void exitMicAirTestActivity() {
        Log.d(TAG, "exitMicAirTestActivity");
        finish();
    }

    @Override // com.ifpdos.factorytest.mic.IUdiMicAirContract
    public MicAirDbListBody getMicDb() {
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < this.mCntMics; i++) {
            arrayList.add(new MicAirDbBody(i, this.mMicSigView[i].mLevelDb));
        }
        return new MicAirDbListBody(arrayList);
    }

    @Override // android.view.Window.Callback
    public void onPointerCaptureChanged(boolean z) {
        super.onPointerCaptureChanged(z);
    }

    @Override // android.app.Activity
    protected void onDestroy() {
        super.onDestroy();
        if (this.mIsFromUdi) {
            MicAirHandler.INSTANCE.unregisterIUdiMicAirImpl(this);
        }
    }
}