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