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

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/16194412

Change-Id: I2594bdb48a4ce38b4a576ef40ea0c641435e9d7c

services/core/java/com/android/server/audio/AudioService.java

@@ -7648,7 +7648,7 @@ public class AudioService extends IAudioService.Stub
                     break;
 
                 case MSG_INIT_HEADTRACKING_SENSORS:
-                    mSpatializerHelper.onInitSensors(/*init*/ msg.arg1 == 1);
+                    mSpatializerHelper.onInitSensors();
                     break;
 
                 case MSG_CHECK_MUSIC_ACTIVE:
@@ -8582,14 +8582,13 @@ public class AudioService extends IAudioService.Stub
 
     /**
      * 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,
                 MSG_INIT_HEADTRACKING_SENSORS,
                 SENDMSG_REPLACE,
-                /*arg1*/ init ? 1 : 0,
+                /*arg1*/ 0, /*arg2*/ 0, TAG, /*delay*/ 0);
-                0, TAG, /*delay*/ 0);
     }
 
     //==========================================================================================

services/core/java/com/android/server/audio/SpatializerHelper.java

@@ -63,6 +63,14 @@ public class SpatializerHelper {
     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
     private static final int STATE_UNINITIALIZED = 0;
     private static final int STATE_NOT_SUPPORTED = 1;
@@ -81,7 +89,7 @@ public class SpatializerHelper {
     private @Nullable ISpatializer mSpat;
     private @Nullable SpatializerCallback mSpatCallback;
     private @Nullable SpatializerHeadTrackingCallback mSpatHeadTrackingCallback;
-
+    private @Nullable HelperDynamicSensorCallback mDynSensorCallback;
 
     // default attributes and format that determine basic availability of spatialization
     private static final AudioAttributes DEFAULT_ATTRIBUTES = new AudioAttributes.Builder()
@@ -209,11 +217,7 @@ public class SpatializerHelper {
             // TODO use reported spat level to change state
 
             // init sensors
-            if (level == SpatializationLevel.NONE) {
+            postInitSensors();
-                initSensors(/*init*/false);
-            } else {
-                postInitSensors(true);
-            }
         }
 
         public void onOutputChanged(int output) {
@@ -229,6 +233,7 @@ public class SpatializerHelper {
         }
     };
 
+    //------------------------------------------------------
     // spatializer head tracking callback from native
     private final class SpatializerHeadTrackingCallback
             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
     /**
@@ -851,48 +870,12 @@ public class SpatializerHelper {
 
     //------------------------------------------------------
     // sensors
-    private void initSensors(boolean init) {
+    private void postInitSensors() {
-        if (mSensorManager == null) {
+        mAudioService.postInitSpatializerHeadTrackingSensors();
-            mSensorManager = (SensorManager)
-                    mAudioService.mContext.getSystemService(Context.SENSOR_SERVICE);
-        }
-        final int headHandle;
-        final int screenHandle;
-        if (init) {
-            if (mSensorManager == null) {
-                Log.e(TAG, "Null SensorManager, can't init sensors");
-                return;
-            }
-            // TODO replace with dynamic association of sensor for headtracker
-            Sensor headSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR);
-            headHandle = headSensor.getHandle();
-            //Sensor screenSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
-            //screenHandle = deviceSensor.getHandle();
-            screenHandle = -1;
-        } else {
-            // -1 is disable value
-            screenHandle = -1;
-            headHandle = -1;
-        }
-        try {
-            Log.i(TAG, "setScreenSensor:" + screenHandle);
-            mSpat.setScreenSensor(screenHandle);
-        } catch (Exception e) {
-            Log.e(TAG, "Error calling setScreenSensor:" + screenHandle, e);
-        }
-        try {
-            Log.i(TAG, "setHeadSensor:" + headHandle);
-            mSpat.setHeadSensor(headHandle);
-        } catch (Exception e) {
-            Log.e(TAG, "Error calling setHeadSensor:" + headHandle, e);
-        }
     }
 
-    private void postInitSensors(boolean init) {
+    synchronized void onInitSensors() {
-        mAudioService.postInitSpatializerHeadTrackingSensors(init);
+        final boolean init = (mSpatLevel != SpatializationLevel.NONE);
-    }
-
-    synchronized void onInitSensors(boolean init) {
         final String action = init ? "initializing" : "releasing";
         if (mSpat == null) {
             Log.e(TAG, "not " + action + " sensors, null spatializer");
@@ -907,7 +890,53 @@ public class SpatializerHelper {
             Log.e(TAG, "not " + action + " sensors, error querying headtracking", e);
             return;
         }
-        initSensors(init);
+        int headHandle = -1;
+        int screenHandle = -1;
+        if (init) {
+            if (mSensorManager == null) {
+                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;
+                }
+            }
+            // initialize sensor handles
+            // TODO-HT update to non-private sensor once head tracker sensor is defined
+            for (Sensor sensor : mSensorManager.getDynamicSensorList(
+                    Sensor.TYPE_DEVICE_PRIVATE_BASE)) {
+                if (sensor.getStringType().equals(HEADTRACKER_SENSOR)) {
+                    headHandle = sensor.getHandle();
+                    break;
+                }
+            }
+            Sensor screenSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
+            screenHandle = screenSensor.getHandle();
+        } else {
+            if (mSensorManager != null && mDynSensorCallback != null) {
+                mSensorManager.unregisterDynamicSensorCallback(mDynSensorCallback);
+                mSensorManager = null;
+                mDynSensorCallback = null;
+            }
+            // -1 is disable value for both screen and head tracker handles
+        }
+        try {
+            Log.i(TAG, "setScreenSensor:" + screenHandle);
+            mSpat.setScreenSensor(screenHandle);
+        } catch (Exception e) {
+            Log.e(TAG, "Error calling setScreenSensor:" + screenHandle, e);
+        }
+        try {
+            Log.i(TAG, "setHeadSensor:" + headHandle);
+            mSpat.setHeadSensor(headHandle);
+        } catch (Exception e) {
+            Log.e(TAG, "Error calling setHeadSensor:" + headHandle, e);
+        }
     }
 
     //------------------------------------------------------