package com.ifpdos.factorytest;

import android.app.Activity;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.RadioGroup;
import androidx.core.internal.view.SupportMenu;
import androidx.databinding.DataBindingUtil;
import com.ifpdos.Utils.UdiUtil;
import com.ifpdos.Utils.okhttp.OkHttpHelper;
import com.ifpdos.factorytest.databinding.ActivityIrTestBinding;
import com.ifpdos.factorytest.entity.BooleanValueBody;
import com.ifpdos.factorytest.entity.PirModel;
import com.ifpdos.factorytest.util.SensorUtil;
import com.seewo.sdk.OsEventBus;
import com.seewo.sdk.event.OSEvent;
import com.seewo.sdk.eventbus.OnEventOfOS;
import com.seewo.sdk.eventbus.ThreadMode;
import io.reactivex.Observable;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import java.util.Locale;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

/* JADX INFO: loaded from: classes.dex */
public class IrSensorTestActivity extends Activity {
    private static final int CODE_NOT_ALLOW = 405;
    private static final int SENSOR_TYPE_HUMAN_DETECTION = 65548;
    private static final String TAG = "IrSensorTestActivity";
    ActivityIrTestBinding binding;
    private String logText;
    private Disposable mTimeDisposable;
    private SensorEventListener pirEventListener;
    PirModel pirModel;
    private String pir_time_tips;
    private SensorManager sensorManager;
    private long mStartTime = 0;
    private Timer logTextTimer = null;
    private boolean timerWorking = false;

    @Override // android.app.Activity
    protected void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        this.binding = (ActivityIrTestBinding) DataBindingUtil.setContentView(this, R.layout.activity_ir_test);
        initUi();
        OsEventBus.getInstance().register(this);
        this.logTextTimer = new Timer();
    }

    private boolean getHumanDetection() {
        try {
            return ((BooleanValueBody) OkHttpHelper.getInstance().get(UdiUtil.URL_HUMAN_DETECT, BooleanValueBody.class)).value;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    private Boolean isSupportHumanDetectionSensitivity() {
        try {
            return Boolean.valueOf(OkHttpHelper.getInstance().executeSync(UdiUtil.URL_HUMAN_DETECT_SENSITIVITY_LIST).code() != 405);
        } catch (Exception e) {
            Log.e(TAG, "isSupportHumanDetectionSensitivity: error", e);
            return true;
        }
    }

    private void hideLogTextTimeTask() {
        if (!this.timerWorking) {
            this.timerWorking = true;
            this.logTextTimer.schedule(new AnonymousClass1(), 2000L);
        } else {
            this.logTextTimer.cancel();
            Timer timer = new Timer();
            this.logTextTimer = timer;
            timer.schedule(new AnonymousClass2(), 2000L);
        }
    }

    /* JADX INFO: renamed from: com.ifpdos.factorytest.IrSensorTestActivity$1, reason: invalid class name */
    class AnonymousClass1 extends TimerTask {
        AnonymousClass1() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$run$0() {
            IrSensorTestActivity.this.binding.textViewIrLog.setVisibility(4);
        }

        @Override // java.util.TimerTask, java.lang.Runnable
        public void run() {
            IrSensorTestActivity.this.runOnUiThread(new Runnable() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$1$$ExternalSyntheticLambda0
                @Override // java.lang.Runnable
                public final void run() {
                    this.f$0.lambda$run$0();
                }
            });
            IrSensorTestActivity.this.timerWorking = false;
        }
    }

    /* JADX INFO: renamed from: com.ifpdos.factorytest.IrSensorTestActivity$2, reason: invalid class name */
    class AnonymousClass2 extends TimerTask {
        AnonymousClass2() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public /* synthetic */ void lambda$run$0() {
            IrSensorTestActivity.this.binding.textViewIrLog.setVisibility(4);
        }

        @Override // java.util.TimerTask, java.lang.Runnable
        public void run() {
            IrSensorTestActivity.this.runOnUiThread(new Runnable() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$2$$ExternalSyntheticLambda0
                @Override // java.lang.Runnable
                public final void run() {
                    this.f$0.lambda$run$0();
                }
            });
            IrSensorTestActivity.this.timerWorking = false;
        }
    }

    private void initUi() {
        boolean humanDetection = getHumanDetection();
        Log.d(TAG, "init human detect,is human detect: " + humanDetection);
        this.pir_time_tips = getString(R.string.pir_time_tips);
        PirModel pirModel = new PirModel(humanDetection, this.pir_time_tips);
        this.pirModel = pirModel;
        this.binding.setPirModel(pirModel);
        this.binding.irPass.setOnClickListener(new View.OnClickListener() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$$ExternalSyntheticLambda0
            @Override // android.view.View.OnClickListener
            public final void onClick(View view) {
                this.f$0.lambda$initUi$0(view);
            }
        });
        this.binding.irFail.setOnClickListener(new View.OnClickListener() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$$ExternalSyntheticLambda1
            @Override // android.view.View.OnClickListener
            public final void onClick(View view) {
                this.f$0.lambda$initUi$1(view);
            }
        });
        if (!isSupportSensitivity()) {
            this.binding.HumanDetectRadioGroup.setVisibility(4);
        }
        if (ConfigParser.hasDualPir()) {
            Log.d(TAG, "hasDualPir: true");
            this.binding.textViewSingleIrStatus.setVisibility(8);
            this.binding.textViewDualIrStatus.setVisibility(0);
            initPirSensor();
        } else {
            Log.d(TAG, "hasDualPir: false");
            this.binding.textViewSingleIrStatus.setVisibility(0);
            this.binding.textViewDualIrStatus.setVisibility(8);
        }
        this.binding.HumanDetectRadioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$$ExternalSyntheticLambda2
            @Override // android.widget.RadioGroup.OnCheckedChangeListener
            public final void onCheckedChanged(RadioGroup radioGroup, int i) {
                this.f$0.lambda$initUi$2(radioGroup, i);
            }
        });
        startTimeTask();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$initUi$0(View view) {
        setResult(1);
        finish();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$initUi$1(View view) {
        setResult(2);
        finish();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$initUi$2(RadioGroup radioGroup, int i) {
        boolean humanDetectionSensitivity;
        int checkedRadioButtonId = radioGroup.getCheckedRadioButtonId();
        if (checkedRadioButtonId == R.id.HumanDetectFactoryModel) {
            humanDetectionSensitivity = SensorUtil.setHumanDetectionSensitivity("FACTORY");
            this.logText = getString(humanDetectionSensitivity ? R.string.factory_mode_success : R.string.factory_mode_fail);
        } else if (checkedRadioButtonId == R.id.HumanDetect2MitModel) {
            humanDetectionSensitivity = SensorUtil.setHumanDetectionSensitivity("LOW");
            this.logText = getString(humanDetectionSensitivity ? R.string.two_meter_mode_success : R.string.two_meter_mode_fail);
        } else if (checkedRadioButtonId == R.id.HumanDetect4MitModel) {
            humanDetectionSensitivity = SensorUtil.setHumanDetectionSensitivity("NORMAL");
            this.logText = getString(humanDetectionSensitivity ? R.string.four_meter_mode_success : R.string.four_meter_mode_fail);
        } else {
            humanDetectionSensitivity = false;
        }
        this.binding.textViewIrLog.setText(this.logText);
        this.binding.textViewIrLog.setVisibility(0);
        this.binding.textViewIrLog.setTextColor(humanDetectionSensitivity ? -16711936 : SupportMenu.CATEGORY_MASK);
        hideLogTextTimeTask();
    }

    private void initPirSensor() {
        Log.e(TAG, "initPirSensor...");
        SensorManager sensorManager = (SensorManager) getSystemService("sensor");
        this.sensorManager = sensorManager;
        Sensor defaultSensor = sensorManager.getDefaultSensor(SENSOR_TYPE_HUMAN_DETECTION);
        if (defaultSensor != null) {
            SensorEventListener sensorEventListener = new SensorEventListener() { // from class: com.ifpdos.factorytest.IrSensorTestActivity.3
                @Override // android.hardware.SensorEventListener
                public void onAccuracyChanged(Sensor sensor, int i) {
                }

                @Override // android.hardware.SensorEventListener
                public void onSensorChanged(SensorEvent sensorEvent) {
                    IrSensorTestActivity.this.updatePirStatus((int) sensorEvent.values[0]);
                }
            };
            this.pirEventListener = sensorEventListener;
            this.sensorManager.registerListener(sensorEventListener, defaultSensor, 3);
            this.mStartTime++;
            updateTimeTips();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void updatePirStatus(int i) {
        final String string;
        final int color;
        final boolean z = true;
        if (i == 0) {
            string = getString(R.string.pir_none_detected);
            color = getColor(R.color.orange);
        } else if (i == 1) {
            string = getString(R.string.pir_1_detected);
            color = getColor(R.color.yellow);
        } else if (i == 2) {
            string = getString(R.string.pir_2_detected);
            color = getColor(R.color.yellow);
        } else if (i == 3) {
            string = getString(R.string.pir_both_detected);
            color = getColor(R.color.green);
            z = false;
        } else {
            string = getString(R.string.pir_unknown_state);
            color = getColor(R.color.gray_pending);
        }
        Log.e(TAG, "PIR status: " + string);
        runOnUiThread(new Runnable() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$$ExternalSyntheticLambda3
            @Override // java.lang.Runnable
            public final void run() {
                this.f$0.lambda$updatePirStatus$3(string, color, z);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$updatePirStatus$3(String str, int i, boolean z) {
        this.pirModel.getDualPirStatusField().set(str);
        this.binding.irLayout.setBackgroundColor(i);
        if (z) {
            this.binding.textViewIrTime.setVisibility(0);
            this.mStartTime = 0L;
            updateTimeTips();
            return;
        }
        this.binding.textViewIrTime.setVisibility(8);
    }

    @OnEventOfOS(threadMode = ThreadMode.MAIN)
    public void onEvent(OSEvent.PersonIdentification personIdentification) {
        if (ConfigParser.hasDualPir()) {
            return;
        }
        Log.d(TAG, "PIR trigger" + personIdentification.state.name());
        int i = AnonymousClass4.$SwitchMap$com$seewo$sdk$event$OSEvent$PersonIdentification$State[personIdentification.state.ordinal()];
        if (i != 1) {
            if (i != 2) {
                return;
            }
            Log.d(TAG, "--> ALL_FIELD human true");
            this.pirModel.getStatusField().set(true);
            return;
        }
        Log.d(TAG, "--> NO_FIELD human false");
        this.mStartTime = 0L;
        updateTimeTips();
        this.pirModel.getStatusField().set(false);
    }

    /* JADX INFO: renamed from: com.ifpdos.factorytest.IrSensorTestActivity$4, reason: invalid class name */
    static /* synthetic */ class AnonymousClass4 {
        static final /* synthetic */ int[] $SwitchMap$com$seewo$sdk$event$OSEvent$PersonIdentification$State;

        static {
            int[] iArr = new int[OSEvent.PersonIdentification.State.values().length];
            $SwitchMap$com$seewo$sdk$event$OSEvent$PersonIdentification$State = iArr;
            try {
                iArr[OSEvent.PersonIdentification.State.NO_FIELD.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$seewo$sdk$event$OSEvent$PersonIdentification$State[OSEvent.PersonIdentification.State.ALL_FIELD.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
        }
    }

    @Override // android.app.Activity
    protected void onDestroy() {
        SensorEventListener sensorEventListener;
        super.onDestroy();
        OsEventBus.getInstance().unregister(this);
        this.mTimeDisposable.dispose();
        SensorManager sensorManager = this.sensorManager;
        if (sensorManager == null || (sensorEventListener = this.pirEventListener) == null) {
            return;
        }
        sensorManager.unregisterListener(sensorEventListener);
    }

    private void updateTimeTips() {
        this.pirModel.getTimeField().set(String.format(Locale.ENGLISH, this.pir_time_tips, Long.valueOf(this.mStartTime / 3600), Long.valueOf((this.mStartTime % 3600) / 60), Long.valueOf(this.mStartTime % 60)));
    }

    private void startTimeTask() {
        this.mTimeDisposable = Observable.interval(0L, 1L, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() { // from class: com.ifpdos.factorytest.IrSensorTestActivity$$ExternalSyntheticLambda4
            @Override // io.reactivex.functions.Consumer
            public final void accept(Object obj) throws Exception {
                this.f$0.lambda$startTimeTask$4((Long) obj);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$startTimeTask$4(Long l) throws Exception {
        this.mStartTime++;
        updateTimeTips();
    }

    private boolean isSupportSensitivity() {
        if (ConfigParser.isBoardType("8195") || ConfigParser.isBoardType("9666") || ConfigParser.isBoardType("3576")) {
            return false;
        }
        return isSupportHumanDetectionSensitivity().booleanValue();
    }
}