Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 54c89ad9 authored by Jean-Michel Trivi's avatar Jean-Michel Trivi Committed by Android (Google) Code Review
Browse files

Merge "AudioService: SpatializerHelper initializes head tracker" into sc-v2-dev

parents 90d2471b 6121d0f2
Loading
Loading
Loading
Loading
+4 −5
Original line number Original line Diff line number Diff line
@@ -7587,7 +7587,7 @@ public class AudioService extends IAudioService.Stub
                    break;
                    break;


                case MSG_INIT_HEADTRACKING_SENSORS:
                case MSG_INIT_HEADTRACKING_SENSORS:
                    mSpatializerHelper.onInitSensors(/*init*/ msg.arg1 == 1);
                    mSpatializerHelper.onInitSensors();
                    break;
                    break;


                case MSG_CHECK_MUSIC_ACTIVE:
                case MSG_CHECK_MUSIC_ACTIVE:
@@ -8521,14 +8521,13 @@ public class AudioService extends IAudioService.Stub


    /**
    /**
     * post a message to schedule init/release of head tracking sensors
     * post a message to schedule init/release of head tracking sensors
     * @param init initialization if true, release if false
     * whether to initialize or release sensors is based on the state of spatializer
     */
     */
    void postInitSpatializerHeadTrackingSensors(boolean init) {
    void postInitSpatializerHeadTrackingSensors() {
        sendMsg(mAudioHandler,
        sendMsg(mAudioHandler,
                MSG_INIT_HEADTRACKING_SENSORS,
                MSG_INIT_HEADTRACKING_SENSORS,
                SENDMSG_REPLACE,
                SENDMSG_REPLACE,
                /*arg1*/ init ? 1 : 0,
                /*arg1*/ 0, /*arg2*/ 0, TAG, /*delay*/ 0);
                0, TAG, /*delay*/ 0);
    }
    }


    //==========================================================================================
    //==========================================================================================
+74 −45
Original line number Original line Diff line number Diff line
@@ -63,6 +63,14 @@ public class SpatializerHelper {
    private @Nullable SensorManager mSensorManager;
    private @Nullable SensorManager mSensorManager;


    //------------------------------------------------------------
    //------------------------------------------------------------
    /** head tracker sensor name */
    // TODO: replace with generic head tracker sensor name.
    //       the current implementation refers to the "google" namespace but will be replaced
    //       by an android name at the next API level revision, it is not Google-specific.
    //       Also see "TODO-HT" in onInitSensors() method
    private static final String HEADTRACKER_SENSOR =
            "com.google.hardware.sensor.hid_dynamic.headtracker";

    // Spatializer state machine
    // Spatializer state machine
    private static final int STATE_UNINITIALIZED = 0;
    private static final int STATE_UNINITIALIZED = 0;
    private static final int STATE_NOT_SUPPORTED = 1;
    private static final int STATE_NOT_SUPPORTED = 1;
@@ -81,7 +89,7 @@ public class SpatializerHelper {
    private @Nullable ISpatializer mSpat;
    private @Nullable ISpatializer mSpat;
    private @Nullable SpatializerCallback mSpatCallback;
    private @Nullable SpatializerCallback mSpatCallback;
    private @Nullable SpatializerHeadTrackingCallback mSpatHeadTrackingCallback;
    private @Nullable SpatializerHeadTrackingCallback mSpatHeadTrackingCallback;

    private @Nullable HelperDynamicSensorCallback mDynSensorCallback;


    // default attributes and format that determine basic availability of spatialization
    // default attributes and format that determine basic availability of spatialization
    private static final AudioAttributes DEFAULT_ATTRIBUTES = new AudioAttributes.Builder()
    private static final AudioAttributes DEFAULT_ATTRIBUTES = new AudioAttributes.Builder()
@@ -209,11 +217,7 @@ public class SpatializerHelper {
            // TODO use reported spat level to change state
            // TODO use reported spat level to change state


            // init sensors
            // init sensors
            if (level == SpatializationLevel.NONE) {
            postInitSensors();
                initSensors(/*init*/false);
            } else {
                postInitSensors(true);
            }
        }
        }


        public void onOutputChanged(int output) {
        public void onOutputChanged(int output) {
@@ -229,6 +233,7 @@ public class SpatializerHelper {
        }
        }
    };
    };


    //------------------------------------------------------
    // spatializer head tracking callback from native
    // spatializer head tracking callback from native
    private final class SpatializerHeadTrackingCallback
    private final class SpatializerHeadTrackingCallback
            extends ISpatializerHeadTrackingCallback.Stub {
            extends ISpatializerHeadTrackingCallback.Stub {
@@ -268,6 +273,20 @@ public class SpatializerHelper {
        }
        }
    };
    };


    //------------------------------------------------------
    // dynamic sensor callback
    private final class HelperDynamicSensorCallback extends SensorManager.DynamicSensorCallback {
        @Override
        public void onDynamicSensorConnected(Sensor sensor) {
            postInitSensors();
        }

        @Override
        public void onDynamicSensorDisconnected(Sensor sensor) {
            postInitSensors();
        }
    }

    //------------------------------------------------------
    //------------------------------------------------------
    // compatible devices
    // compatible devices
    /**
    /**
@@ -851,28 +870,60 @@ public class SpatializerHelper {


    //------------------------------------------------------
    //------------------------------------------------------
    // sensors
    // sensors
    private void initSensors(boolean init) {
    private void postInitSensors() {
        if (mSensorManager == null) {
        mAudioService.postInitSpatializerHeadTrackingSensors();
            mSensorManager = (SensorManager)
    }
                    mAudioService.mContext.getSystemService(Context.SENSOR_SERVICE);

    synchronized void onInitSensors() {
        final boolean init = (mSpatLevel != SpatializationLevel.NONE);
        final String action = init ? "initializing" : "releasing";
        if (mSpat == null) {
            Log.e(TAG, "not " + action + " sensors, null spatializer");
            return;
        }
        try {
            if (!mSpat.isHeadTrackingSupported()) {
                Log.e(TAG, "not " + action + " sensors, spatializer doesn't support headtracking");
                return;
            }
        } catch (RemoteException e) {
            Log.e(TAG, "not " + action + " sensors, error querying headtracking", e);
            return;
        }
        }
        final int headHandle;
        int headHandle = -1;
        final int screenHandle;
        int screenHandle = -1;
        if (init) {
        if (init) {
            if (mSensorManager == null) {
            if (mSensorManager == null) {
                Log.e(TAG, "Null SensorManager, can't init sensors");
                try {
                    mSensorManager = (SensorManager)
                            mAudioService.mContext.getSystemService(Context.SENSOR_SERVICE);
                    mDynSensorCallback = new HelperDynamicSensorCallback();
                    mSensorManager.registerDynamicSensorCallback(mDynSensorCallback);
                } catch (Exception e) {
                    Log.e(TAG, "Error with SensorManager, can't initialize sensors", e);
                    mSensorManager = null;
                    mDynSensorCallback = null;
                    return;
                    return;
                }
                }
            // TODO replace with dynamic association of sensor for headtracker
            }
            Sensor headSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);
            // initialize sensor handles
            headHandle = headSensor.getHandle();
            // TODO-HT update to non-private sensor once head tracker sensor is defined
            //Sensor screenSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
            for (Sensor sensor : mSensorManager.getDynamicSensorList(
            //screenHandle = deviceSensor.getHandle();
                    Sensor.TYPE_DEVICE_PRIVATE_BASE)) {
            screenHandle = -1;
                if (sensor.getStringType().equals(HEADTRACKER_SENSOR)) {
                    headHandle = sensor.getHandle();
                    break;
                }
            }
            Sensor screenSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
            screenHandle = screenSensor.getHandle();
        } else {
        } else {
            // -1 is disable value
            if (mSensorManager != null && mDynSensorCallback != null) {
            screenHandle = -1;
                mSensorManager.unregisterDynamicSensorCallback(mDynSensorCallback);
            headHandle = -1;
                mSensorManager = null;
                mDynSensorCallback = null;
            }
            // -1 is disable value for both screen and head tracker handles
        }
        }
        try {
        try {
            Log.i(TAG, "setScreenSensor:" + screenHandle);
            Log.i(TAG, "setScreenSensor:" + screenHandle);
@@ -888,28 +939,6 @@ public class SpatializerHelper {
        }
        }
    }
    }


    private void postInitSensors(boolean init) {
        mAudioService.postInitSpatializerHeadTrackingSensors(init);
    }

    synchronized void onInitSensors(boolean init) {
        final String action = init ? "initializing" : "releasing";
        if (mSpat == null) {
            Log.e(TAG, "not " + action + " sensors, null spatializer");
            return;
        }
        try {
            if (!mSpat.isHeadTrackingSupported()) {
                Log.e(TAG, "not " + action + " sensors, spatializer doesn't support headtracking");
                return;
            }
        } catch (RemoteException e) {
            Log.e(TAG, "not " + action + " sensors, error querying headtracking", e);
            return;
        }
        initSensors(init);
    }

    //------------------------------------------------------
    //------------------------------------------------------
    // SDK <-> AIDL converters
    // SDK <-> AIDL converters
    private static int headTrackingModeTypeToSpatializerInt(byte mode) {
    private static int headTrackingModeTypeToSpatializerInt(byte mode) {