Remove dependency on libandroid
The main purpose of this change is to avoid having to pull in libandroid
for the sake of using the sensor manager from the audioserver process
(native). The way this is achieved is by using lower-level APIs, namely
those offered by libsensor.
As a result, we were able to use sensor handles in SensorPoseProvider,
rather than ASensor* objects, which is simpler and removes the need to
enumerate all the sensor for the sake of finding the one with the
correct handle.
Test: Manually enable head tracking and observe the logs to verify that
the expected pose updates are received.
Bug: 198795859
Change-Id: Ic69c322d6ea9297309a4856b3047c841831e04d7
diff --git a/media/libheadtracking/Android.bp b/media/libheadtracking/Android.bp
index d134ca0..63b769e 100644
--- a/media/libheadtracking/Android.bp
+++ b/media/libheadtracking/Android.bp
@@ -38,9 +38,9 @@
],
shared_libs: [
"libheadtracking",
- "libandroid",
"liblog",
"libsensor",
+ "libutils",
],
export_shared_lib_headers: [
"libheadtracking",
@@ -53,7 +53,6 @@
"SensorPoseProvider-example.cpp",
],
shared_libs: [
- "libandroid",
"libheadtracking",
"libheadtracking-binding",
"libsensor",
diff --git a/media/libheadtracking/SensorPoseProvider-example.cpp b/media/libheadtracking/SensorPoseProvider-example.cpp
index 13db07e..a246e8b 100644
--- a/media/libheadtracking/SensorPoseProvider-example.cpp
+++ b/media/libheadtracking/SensorPoseProvider-example.cpp
@@ -22,12 +22,19 @@
#include <utils/SystemClock.h>
#include <media/SensorPoseProvider.h>
+#include <sensor/Sensor.h>
+#include <sensor/SensorManager.h>
using android::elapsedRealtimeNano;
+using android::Sensor;
+using android::SensorManager;
+using android::String16;
using android::media::Pose3f;
using android::media::SensorPoseProvider;
using android::media::Twist3f;
+using namespace std::chrono_literals;
+
const char kPackageName[] = "SensorPoseProvider-example";
class Listener : public SensorPoseProvider::Listener {
@@ -51,24 +58,18 @@
};
int main() {
- ASensorManager* sensor_manager = ASensorManager_getInstanceForPackage(kPackageName);
- if (!sensor_manager) {
- std::cerr << "Failed to get a sensor manager" << std::endl;
- return 1;
- }
+ SensorManager& sensorManager = SensorManager::getInstanceForPackage(String16(kPackageName));
- const ASensor* headSensor =
- ASensorManager_getDefaultSensor(sensor_manager, SENSOR_TYPE_GAME_ROTATION_VECTOR);
- const ASensor* screenSensor =
- ASensorManager_getDefaultSensor(sensor_manager, SENSOR_TYPE_ROTATION_VECTOR);
+ const Sensor* headSensor = sensorManager.getDefaultSensor(SENSOR_TYPE_GAME_ROTATION_VECTOR);
+ const Sensor* screenSensor = sensorManager.getDefaultSensor(SENSOR_TYPE_ROTATION_VECTOR);
Listener listener;
std::unique_ptr<SensorPoseProvider> provider =
SensorPoseProvider::create(kPackageName, &listener);
- int32_t headHandle = provider->startSensor(headSensor, std::chrono::milliseconds(500));
+ int32_t headHandle = provider->startSensor(headSensor->getHandle(), 500ms);
sleep(2);
- provider->startSensor(screenSensor, std::chrono::milliseconds(500));
+ provider->startSensor(screenSensor->getHandle(), 500ms);
sleep(2);
provider->stopSensor(headHandle);
sleep(2);
diff --git a/media/libheadtracking/SensorPoseProvider.cpp b/media/libheadtracking/SensorPoseProvider.cpp
index cfa23d0..c4c031d 100644
--- a/media/libheadtracking/SensorPoseProvider.cpp
+++ b/media/libheadtracking/SensorPoseProvider.cpp
@@ -24,8 +24,11 @@
#include <map>
#include <thread>
-#include <android/looper.h>
#include <log/log_main.h>
+#include <sensor/Sensor.h>
+#include <sensor/SensorEventQueue.h>
+#include <sensor/SensorManager.h>
+#include <utils/Looper.h>
#include "QuaternionUtil.h"
@@ -33,31 +36,42 @@
namespace media {
namespace {
+// Identifier to use for our event queue on the loop.
+// The number 19 is arbitrary, only useful if using multiple objects on the same looper.
+constexpr int kIdent = 19;
+
+static inline Looper* ALooper_to_Looper(ALooper* alooper) {
+ return reinterpret_cast<Looper*>(alooper);
+}
+
+static inline ALooper* Looper_to_ALooper(Looper* looper) {
+ return reinterpret_cast<ALooper*>(looper);
+}
+
/**
- * RAII-wrapper around ASensorEventQueue, which destroys it on destruction.
+ * RAII-wrapper around SensorEventQueue, which unregisters it on destruction.
*/
class EventQueueGuard {
public:
- EventQueueGuard(ASensorManager* manager, ASensorEventQueue* queue)
- : mManager(manager), mQueue(queue) {}
+ EventQueueGuard(const sp<SensorEventQueue>& queue, Looper* looper) : mQueue(queue) {
+ mQueue->looper = Looper_to_ALooper(looper);
+ mQueue->requestAdditionalInfo = false;
+ looper->addFd(mQueue->getFd(), kIdent, ALOOPER_EVENT_INPUT, nullptr, nullptr);
+ }
~EventQueueGuard() {
if (mQueue) {
- int ret = ASensorManager_destroyEventQueue(mManager, mQueue);
- if (ret) {
- ALOGE("Failed to destroy event queue: %s\n", strerror(ret));
- }
+ ALooper_to_Looper(mQueue->looper)->removeFd(mQueue->getFd());
}
}
EventQueueGuard(const EventQueueGuard&) = delete;
EventQueueGuard& operator=(const EventQueueGuard&) = delete;
- [[nodiscard]] ASensorEventQueue* get() const { return mQueue; }
+ [[nodiscard]] SensorEventQueue* get() const { return mQueue.get(); }
private:
- ASensorManager* const mManager;
- ASensorEventQueue* mQueue;
+ sp<SensorEventQueue> mQueue;
};
/**
@@ -65,12 +79,12 @@
*/
class SensorEnableGuard {
public:
- SensorEnableGuard(ASensorEventQueue* queue, const ASensor* sensor)
+ SensorEnableGuard(const sp<SensorEventQueue>& queue, int32_t sensor)
: mQueue(queue), mSensor(sensor) {}
~SensorEnableGuard() {
- if (mSensor) {
- int ret = ASensorEventQueue_disableSensor(mQueue, mSensor);
+ if (mSensor != SensorPoseProvider::INVALID_HANDLE) {
+ int ret = mQueue->disableSensor(mSensor);
if (ret) {
ALOGE("Failed to disable sensor: %s\n", strerror(ret));
}
@@ -82,12 +96,12 @@
// Enable moving.
SensorEnableGuard(SensorEnableGuard&& other) : mQueue(other.mQueue), mSensor(other.mSensor) {
- other.mSensor = nullptr;
+ other.mSensor = SensorPoseProvider::INVALID_HANDLE;
}
private:
- ASensorEventQueue* const mQueue;
- const ASensor* mSensor;
+ sp<SensorEventQueue> const mQueue;
+ int32_t mSensor;
};
/**
@@ -104,32 +118,30 @@
~SensorPoseProviderImpl() override {
// Disable all active sensors.
mEnabledSensors.clear();
- ALooper_wake(mLooper);
+ mLooper->wake();
mThread.join();
}
- int32_t startSensor(const ASensor* sensor, std::chrono::microseconds samplingPeriod) override {
- int32_t handle = ASensor_getHandle(sensor);
-
+ bool startSensor(int32_t sensor, std::chrono::microseconds samplingPeriod) override {
// Enable the sensor.
- if (ASensorEventQueue_registerSensor(mQueue, sensor, samplingPeriod.count(), 0)) {
+ if (mQueue->enableSensor(sensor, samplingPeriod.count(), 0, 0)) {
ALOGE("Failed to enable sensor");
- return INVALID_HANDLE;
+ return false;
}
- mEnabledSensors.emplace(handle, SensorEnableGuard(mQueue, sensor));
- return handle;
+ mEnabledSensors.emplace(sensor, SensorEnableGuard(mQueue.get(), sensor));
+ return true;
}
void stopSensor(int handle) override { mEnabledSensors.erase(handle); }
private:
- ALooper* mLooper;
+ sp<Looper> mLooper;
Listener* const mListener;
std::thread mThread;
std::map<int32_t, SensorEnableGuard> mEnabledSensors;
- ASensorEventQueue* mQueue;
+ sp<SensorEventQueue> mQueue;
// We must do some of the initialization operations on the worker thread, because the API relies
// on the thread-local looper. In addition, as a matter of convenience, we store some of the
@@ -149,21 +161,13 @@
void threadFunc(const char* packageName) {
// Obtain looper.
- mLooper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
-
- // The number 19 is arbitrary, only useful if using multiple objects on the same looper.
- constexpr int kIdent = 19;
+ mLooper = Looper::prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
// Obtain sensor manager.
- ASensorManager* sensor_manager = ASensorManager_getInstanceForPackage(packageName);
- if (!sensor_manager) {
- ALOGE("Failed to get a sensor manager");
- initFinished(false);
- return;
- }
+ SensorManager& sensorManager = SensorManager::getInstanceForPackage(String16(packageName));
// Create event queue.
- mQueue = ASensorManager_createEventQueue(sensor_manager, mLooper, kIdent, nullptr, nullptr);
+ mQueue = sensorManager.createEventQueue();
if (mQueue == nullptr) {
ALOGE("Failed to create a sensor event queue");
@@ -171,12 +175,12 @@
return;
}
- EventQueueGuard eventQueueGuard(sensor_manager, mQueue);
+ EventQueueGuard eventQueueGuard(mQueue, mLooper.get());
initFinished(true);
while (true) {
- int ret = ALooper_pollOnce(-1 /* no timeout */, nullptr, nullptr, nullptr);
+ int ret = mLooper->pollOnce(-1 /* no timeout */, nullptr, nullptr, nullptr);
switch (ret) {
case ALOOPER_POLL_WAKE:
@@ -188,14 +192,19 @@
break;
default:
- ALOGE("Unexpected status out of ALooper_pollOnce: %d", ret);
+ ALOGE("Unexpected status out of Looper::pollOnce: %d", ret);
}
// Process an event.
ASensorEvent event;
- ssize_t size = ASensorEventQueue_getEvents(mQueue, &event, 1);
+ ssize_t actual = mQueue->read(&event, 1);
+ if (actual > 0) {
+ mQueue->sendAck(&event, actual);
+ }
+ ssize_t size = mQueue->filterEvents(&event, actual);
+
if (size < 0 || size > 1) {
- ALOGE("Unexpected return value from ASensorEventQueue_getEvents: %zd", size);
+ ALOGE("Unexpected return value from SensorEventQueue::filterEvents: %zd", size);
break;
}
if (size == 0) {
diff --git a/media/libheadtracking/include/media/SensorPoseProvider.h b/media/libheadtracking/include/media/SensorPoseProvider.h
index 3e9c107..1a5deb0 100644
--- a/media/libheadtracking/include/media/SensorPoseProvider.h
+++ b/media/libheadtracking/include/media/SensorPoseProvider.h
@@ -81,17 +81,14 @@
* @param sensor The sensor to subscribe to.
* @param samplingPeriod Sampling interval, in microseconds. Actual rate might be slightly
* different.
- * @return The sensor handle, which can be later used for stopSensor(). INVALID_HANDLE would be
- * returned in case of error. This is guaranteed to be the same handle as the one returned by
- * ASensor_getHandle(sensor).
+ * @return true iff succeeded.
*/
- virtual int32_t startSensor(const ASensor* sensor,
- std::chrono::microseconds samplingPeriod) = 0;
+ virtual bool startSensor(int32_t sensor, std::chrono::microseconds samplingPeriod) = 0;
/**
* Stop a sensor, previously started with startSensor(). It is not required to stop all sensors
* before deleting the SensorPoseProvider instance.
- * @param handle The sensor handle, as returned from startSensor().
+ * @param handle The sensor handle, as provided to startSensor().
*/
virtual void stopSensor(int32_t handle) = 0;
};
diff --git a/services/audiopolicy/service/Android.bp b/services/audiopolicy/service/Android.bp
index 834478f..197f183 100644
--- a/services/audiopolicy/service/Android.bp
+++ b/services/audiopolicy/service/Android.bp
@@ -26,7 +26,6 @@
shared_libs: [
"libactivitymanager_aidl",
- "libandroid",
"libaudioclient",
"libaudioclient_aidl_conversion",
"libaudiofoundation",
diff --git a/services/audiopolicy/service/Spatializer.cpp b/services/audiopolicy/service/Spatializer.cpp
index 32499f4..502a8d0 100644
--- a/services/audiopolicy/service/Spatializer.cpp
+++ b/services/audiopolicy/service/Spatializer.cpp
@@ -25,7 +25,6 @@
#include <sys/types.h>
#include <android/content/AttributionSourceState.h>
-#include <android/sensor.h>
#include <audio_utils/fixedfft.h>
#include <cutils/bitops.h>
#include <hardware/sensors.h>
@@ -346,9 +345,9 @@
modes->push_back(SpatializerHeadTrackingMode::DISABLED);
if (mSupportsHeadTracking) {
- if (mHeadSensor != nullptr) {
+ if (mHeadSensor != SpatializerPoseController::INVALID_SENSOR) {
modes->push_back(SpatializerHeadTrackingMode::RELATIVE_WORLD);
- if (mScreenSensor != nullptr) {
+ if (mScreenSensor != SpatializerPoseController::INVALID_SENSOR) {
modes->push_back(SpatializerHeadTrackingMode::RELATIVE_SCREEN);
}
}
@@ -451,11 +450,7 @@
return binderStatusFromStatusT(INVALID_OPERATION);
}
std::lock_guard lock(mLock);
- if (sensorHandle == ASENSOR_INVALID) {
- mHeadSensor = nullptr;
- } else {
- mHeadSensor = VALUE_OR_RETURN_BINDER_STATUS(getSensorFromHandle(sensorHandle));
- }
+ mHeadSensor = sensorHandle;
if (mPoseController != nullptr) {
mPoseController->setHeadSensor(mHeadSensor);
}
@@ -468,11 +463,7 @@
return binderStatusFromStatusT(INVALID_OPERATION);
}
std::lock_guard lock(mLock);
- if (sensorHandle == ASENSOR_INVALID) {
- mScreenSensor = nullptr;
- } else {
- mScreenSensor = VALUE_OR_RETURN_BINDER_STATUS(getSensorFromHandle(sensorHandle));
- }
+ mScreenSensor = sensorHandle;
if (mPoseController != nullptr) {
mPoseController->setScreenSensor(mScreenSensor);
}
@@ -634,24 +625,6 @@
}
}
-/* static */
-ConversionResult<ASensorRef> Spatializer::getSensorFromHandle(int handle) {
- ASensorManager* sensorManager =
- ASensorManager_getInstanceForPackage("headtracker");
- if (!sensorManager) {
- ALOGE("Failed to get a sensor manager");
- return base::unexpected(NO_INIT);
- }
- ASensorList sensorList;
- int numSensors = ASensorManager_getSensorList(sensorManager, &sensorList);
- for (int i = 0; i < numSensors; ++i) {
- if (ASensor_getHandle(sensorList[i]) == handle) {
- return sensorList[i];
- }
- }
- return base::unexpected(BAD_VALUE);
-}
-
status_t Spatializer::attachOutput(audio_io_handle_t output) {
std::shared_ptr<SpatializerPoseController> poseController;
{
diff --git a/services/audiopolicy/service/Spatializer.h b/services/audiopolicy/service/Spatializer.h
index 136a467..4d77b78 100644
--- a/services/audiopolicy/service/Spatializer.h
+++ b/services/audiopolicy/service/Spatializer.h
@@ -22,7 +22,6 @@
#include <android/media/SpatializationLevel.h>
#include <android/media/SpatializationMode.h>
#include <android/media/SpatializerHeadTrackingMode.h>
-#include <android/sensor.h>
#include <media/audiohal/EffectHalInterface.h>
#include <media/stagefright/foundation/ALooper.h>
#include <media/AudioEffect.h>
@@ -162,9 +161,6 @@
void onHeadToStagePoseMsg(const std::vector<float>& headToStage);
void onActualModeChangeMsg(media::HeadTrackingMode mode);
-
- static ConversionResult<ASensorRef> getSensorFromHandle(int handle);
-
static constexpr int kMaxEffectParamValues = 10;
/**
* Get a parameter from spatializer engine by calling the effect HAL command method directly.
@@ -312,10 +308,10 @@
= media::SpatializerHeadTrackingMode::DISABLED;
/** Selected Head pose sensor */
- ASensorRef mHeadSensor GUARDED_BY(mLock) = nullptr;
+ int32_t mHeadSensor GUARDED_BY(mLock) = SpatializerPoseController::INVALID_SENSOR;
/** Selected Screen pose sensor */
- ASensorRef mScreenSensor GUARDED_BY(mLock) = nullptr;
+ int32_t mScreenSensor GUARDED_BY(mLock) = SpatializerPoseController::INVALID_SENSOR;
/** Last display orientation received */
static constexpr float kDisplayOrientationInvalid = 1000;
diff --git a/services/audiopolicy/service/SpatializerPoseController.cpp b/services/audiopolicy/service/SpatializerPoseController.cpp
index 215f899..eb23298 100644
--- a/services/audiopolicy/service/SpatializerPoseController.cpp
+++ b/services/audiopolicy/service/SpatializerPoseController.cpp
@@ -17,6 +17,7 @@
#define LOG_TAG "SpatializerPoseController"
//#define LOG_NDEBUG 0
+#include <sensor/Sensor.h>
#include <utils/Log.h>
#include <utils/SystemClock.h>
@@ -129,45 +130,47 @@
mThread.join();
}
-void SpatializerPoseController::setHeadSensor(const ASensor* sensor) {
+void SpatializerPoseController::setHeadSensor(int32_t sensor) {
std::lock_guard lock(mMutex);
// Stop current sensor, if valid and different from the other sensor.
- if (mHeadSensor != SensorPoseProvider::INVALID_HANDLE && mHeadSensor != mScreenSensor) {
+ if (mHeadSensor != INVALID_SENSOR && mHeadSensor != mScreenSensor) {
mPoseProvider->stopSensor(mHeadSensor);
}
- if (sensor != nullptr) {
- if (ASensor_getHandle(sensor) != mScreenSensor) {
+ if (sensor != INVALID_SENSOR) {
+ if (sensor != mScreenSensor) {
// Start new sensor.
- mHeadSensor = mPoseProvider->startSensor(sensor, mSensorPeriod);
+ mHeadSensor =
+ mPoseProvider->startSensor(sensor, mSensorPeriod) ? sensor : INVALID_SENSOR;
} else {
// Sensor is already enabled.
mHeadSensor = mScreenSensor;
}
} else {
- mHeadSensor = SensorPoseProvider::INVALID_HANDLE;
+ mHeadSensor = INVALID_SENSOR;
}
mProcessor->recenter(true, false);
}
-void SpatializerPoseController::setScreenSensor(const ASensor* sensor) {
+void SpatializerPoseController::setScreenSensor(int32_t sensor) {
std::lock_guard lock(mMutex);
// Stop current sensor, if valid and different from the other sensor.
- if (mScreenSensor != SensorPoseProvider::INVALID_HANDLE && mScreenSensor != mHeadSensor) {
+ if (mScreenSensor != INVALID_SENSOR && mScreenSensor != mHeadSensor) {
mPoseProvider->stopSensor(mScreenSensor);
}
- if (sensor != nullptr) {
- if (ASensor_getHandle(sensor) != mHeadSensor) {
+ if (sensor != INVALID_SENSOR) {
+ if (sensor != mHeadSensor) {
// Start new sensor.
- mScreenSensor = mPoseProvider->startSensor(sensor, mSensorPeriod);
+ mScreenSensor =
+ mPoseProvider->startSensor(sensor, mSensorPeriod) ? sensor : INVALID_SENSOR;
} else {
// Sensor is already enabled.
mScreenSensor = mHeadSensor;
}
} else {
- mScreenSensor = SensorPoseProvider::INVALID_HANDLE;
+ mScreenSensor = INVALID_SENSOR;
}
mProcessor->recenter(false, true);
diff --git a/services/audiopolicy/service/SpatializerPoseController.h b/services/audiopolicy/service/SpatializerPoseController.h
index 12898aa..c579622 100644
--- a/services/audiopolicy/service/SpatializerPoseController.h
+++ b/services/audiopolicy/service/SpatializerPoseController.h
@@ -42,6 +42,8 @@
*/
class SpatializerPoseController : private media::SensorPoseProvider::Listener {
public:
+ static constexpr int32_t INVALID_SENSOR = media::SensorPoseProvider::INVALID_HANDLE;
+
/**
* Listener interface for getting pose and mode updates.
* Methods will always be invoked from a designated thread.
@@ -68,15 +70,15 @@
/**
* Set the sensor that is to be used for head-tracking.
- * nullptr can be used to disable head-tracking.
+ * INVALID_SENSOR can be used to disable head-tracking.
*/
- void setHeadSensor(const ASensor* sensor);
+ void setHeadSensor(int32_t sensor);
/**
* Set the sensor that is to be used for screen-tracking.
- * nullptr can be used to disable screen-tracking.
+ * INVALID_SENSOR can be used to disable screen-tracking.
*/
- void setScreenSensor(const ASensor* sensor);
+ void setScreenSensor(int32_t sensor);
/** Sets the desired head-tracking mode. */
void setDesiredMode(media::HeadTrackingMode mode);