Merge "Remove dependency on libandroid" into sc-v2-dev
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);