package com.seewo.sdk.sensor;

import android.os.Handler;
import android.os.Message;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public enum SensorChangedHelper {
    I;

    private static final int DISTANCE = 2;
    public static final int SENSOR_H = 1;
    public static final int SENSOR_ROTATE = 3;
    public static final int SENSOR_V = 2;
    private static final int WHAT_SENSOR_CHANGED = 2;
    private static final int WHAT_SENSOR_DEGREES_CHANGED = 1;
    private DegreesHelper mDegreesHelper;
    private ISDKSensor mISDKSensorManager;
    private int mType = -1;
    private float mPreDegrees = -1.0f;
    private List<OnSensorChangedListener> mOnSensorChangedListeners = new ArrayList();
    private List<OnSensorDegreesChangedListener> mOnSensorDegreesChangedListeners = new ArrayList();
    private boolean mRequested = false;
    private Handler mHandler = new Handler() { // from class: com.seewo.sdk.sensor.SensorChangedHelper.1
        @Override // android.os.Handler
        public void handleMessage(Message message) {
            if (message.what == 1) {
                Iterator it = SensorChangedHelper.this.mOnSensorDegreesChangedListeners.iterator();
                while (it.hasNext()) {
                    ((OnSensorDegreesChangedListener) it.next()).onSensorChanges(((Float) message.obj).floatValue());
                }
            } else if (message.what == 2) {
                Iterator it2 = SensorChangedHelper.this.mOnSensorChangedListeners.iterator();
                while (it2.hasNext()) {
                    ((OnSensorChangedListener) it2.next()).onSensorChanges(((Integer) message.obj).intValue());
                }
            }
        }
    };

    public interface OnSensorChangedListener {
        void onSensorChanges(int i);
    }

    public interface OnSensorDegreesChangedListener {
        void onSensorChanges(float f);
    }

    SensorChangedHelper() {
    }

    public void addSensorChangedListener(OnSensorChangedListener onSensorChangedListener) {
        this.mOnSensorChangedListeners.add(onSensorChangedListener);
    }

    public void removeSensorChangedListener(OnSensorChangedListener onSensorChangedListener) {
        this.mOnSensorChangedListeners.remove(onSensorChangedListener);
    }

    public void addSensorDegreesChangedListener(OnSensorDegreesChangedListener onSensorDegreesChangedListener) {
        this.mOnSensorDegreesChangedListeners.add(onSensorDegreesChangedListener);
    }

    public void removeSensorDegreesChangedListener(OnSensorDegreesChangedListener onSensorDegreesChangedListener) {
        this.mOnSensorDegreesChangedListeners.remove(onSensorDegreesChangedListener);
    }

    public int getCurrentType() {
        int i = this.mType;
        if (i == -1) {
            return 1;
        }
        return i;
    }

    public float getCurrentDegrees() {
        float f = this.mPreDegrees;
        if (f == -1.0f) {
            return 0.0f;
        }
        return f;
    }

    public void initSensorType() {
        SensorType sensorType = SensorType.MCU;
        initSensorType(SensorType.ANDROID);
    }

    public void initSensorType(SensorType sensorType) {
        if (sensorType == SensorType.ANDROID) {
            this.mISDKSensorManager = AndroidSensorManager.getInstance();
            this.mDegreesHelper = new DegreesHelper(1);
        } else if (sensorType == SensorType.MCU) {
            this.mISDKSensorManager = SDKSensorManager.getInstance();
            this.mDegreesHelper = new DegreesHelper(3);
        }
    }

    public void requestSDKSensor(String str) {
        if (this.mISDKSensorManager == null) {
            initSensorType();
        }
        if (this.mRequested) {
            return;
        }
        this.mRequested = this.mISDKSensorManager.registerCallBack(str, new ISDKSensorCallback() { // from class: com.seewo.sdk.sensor.SensorChangedHelper.2
            @Override // com.seewo.sdk.sensor.ISDKSensorCallback
            public void onSensorChanged(float[] fArr, long j) {
                SensorChangedHelper.this.sensorChanged(fArr, j);
            }
        });
    }

    public void unRequestSDKSensor(String str) {
        ISDKSensor iSDKSensor;
        if (!this.mRequested || (iSDKSensor = this.mISDKSensorManager) == null) {
            return;
        }
        iSDKSensor.unRegisterCallBack(str);
        this.mOnSensorChangedListeners.clear();
        this.mOnSensorDegreesChangedListeners.clear();
        this.mRequested = false;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sensorChanged(float[] fArr, long j) {
        DegreesHelper degreesHelper = this.mDegreesHelper;
        if (degreesHelper == null) {
            return;
        }
        float suggestDegrees = degreesHelper.getSuggestDegrees(fArr[0], fArr[1], fArr[5], j);
        float f = this.mPreDegrees;
        if (f == -1.0f || !isFloatSame(suggestDegrees, f)) {
            if (suggestDegrees <= 2.0f && suggestDegrees >= -2.0f) {
                this.mType = 1;
            } else if ((suggestDegrees <= 90.0f && suggestDegrees >= 88.0f) || (suggestDegrees >= -90.0f && suggestDegrees <= -88.0f)) {
                this.mType = 2;
            } else {
                this.mType = 3;
            }
            handleSensorChanged(this.mType);
            handleSensorDegreesChanged(suggestDegrees);
            this.mPreDegrees = suggestDegrees;
        }
    }

    private void handleSensorChanged(int i) {
        Message message = new Message();
        message.obj = Integer.valueOf(i);
        message.what = 2;
        this.mHandler.sendMessage(message);
    }

    private void handleSensorDegreesChanged(float f) {
        Message message = new Message();
        message.obj = Float.valueOf(f);
        message.what = 1;
        this.mHandler.sendMessage(message);
    }

    private boolean isFloatSame(float f, float f2) {
        return ((double) Math.abs(f - f2)) <= 0.1d;
    }
}