Merge "AudioService: SpatializerHelper initializes head tracker" into sc-v2-dev (54c89ad9) · Commits · e / os / android_frameworks_base

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

+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);
	}		}

	//==========================================================================================		//==========================================================================================

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

+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) {