Revert "libsensorndkbridge now with AIDL!"

Revert submission 20604582-sensorndbridgeaidl

Reason for revert: Broke camera and was not caught in presubmits somehow
b/261611999

Reverted Changes:
I702adf847:libsensorndkbridge now with AIDL!
I8f4d62edf:Replace incorrect sensor includes
Icf177531c:Replace incorrect sensor includes
I56791e693:Update POC for changess in libsensorndkbridge

Change-Id: Ifd997b2d21c1e6995677f1eba55dedf11ffe91cc
(cherry picked from commit cccfaf25f921ca612dffaa99901afa3cf1c54086)
Merged-In: Ifd997b2d21c1e6995677f1eba55dedf11ffe91cc
diff --git a/sensorservice/libsensorndkbridge/ALooper.cpp b/sensorservice/libsensorndkbridge/ALooper.cpp
index a4cb8cf..d3ddbff 100644
--- a/sensorservice/libsensorndkbridge/ALooper.cpp
+++ b/sensorservice/libsensorndkbridge/ALooper.cpp
@@ -23,14 +23,16 @@
 #include <android-base/logging.h>
 
 using android::Mutex;
+using android::sp;
+using android::wp;
 
 ALooper::ALooper()
     : mAwoken(false) {
 }
 
-void ALooper::signalSensorEvents(const std::shared_ptr<ASensorEventQueue>& queue) {
+void ALooper::signalSensorEvents(wp<ASensorEventQueue> queue) {
     Mutex::Autolock autoLock(mLock);
-    mReadyQueues.push_back(std::weak_ptr<ASensorEventQueue>(queue));
+    mReadyQueues.insert(queue);
     mCondition.signal();
 }
 
@@ -72,7 +74,7 @@
         result = ALOOPER_POLL_CALLBACK;
 
         for (auto& queue : mReadyQueues) {
-            std::shared_ptr<ASensorEventQueue> promotedQueue = queue.lock();
+            sp<ASensorEventQueue> promotedQueue = queue.promote();
             if (promotedQueue != nullptr) {
                 promotedQueue->dispatchCallback();
             }
@@ -89,13 +91,7 @@
     return result;
 }
 
-void ALooper::invalidateSensorQueue(const std::shared_ptr<ASensorEventQueue>& queue) {
+void ALooper::invalidateSensorQueue(wp<ASensorEventQueue> queue) {
     Mutex::Autolock autoLock(mLock);
-
-    mReadyQueues.erase(std::remove_if(mReadyQueues.begin(), mReadyQueues.end(),
-                                      [&](const std::weak_ptr<ASensorEventQueue>& ptr) {
-                                          std::shared_ptr<ASensorEventQueue> in = ptr.lock();
-                                          return (in == nullptr) || (in == queue);
-                                      }),
-                       mReadyQueues.end());
+    mReadyQueues.erase(queue);
 }
diff --git a/sensorservice/libsensorndkbridge/ALooper.h b/sensorservice/libsensorndkbridge/ALooper.h
index 4a9093f..5fa2b62 100644
--- a/sensorservice/libsensorndkbridge/ALooper.h
+++ b/sensorservice/libsensorndkbridge/ALooper.h
@@ -23,25 +23,25 @@
 #include <utils/Mutex.h>
 #include <utils/RefBase.h>
 
-#include <vector>
+#include <set>
 
 struct ASensorEventQueue;
 
 struct ALooper {
     ALooper();
 
-    void signalSensorEvents(const std::shared_ptr<ASensorEventQueue>& queue);
+    void signalSensorEvents(android::wp<ASensorEventQueue> queue);
     void wake();
 
     int pollOnce(int timeoutMillis, int *outFd, int *outEvents, void **outData);
 
-    void invalidateSensorQueue(const std::shared_ptr<ASensorEventQueue>& queue);
+    void invalidateSensorQueue(android::wp<ASensorEventQueue> queue);
 
    private:
     android::Mutex mLock;
     android::Condition mCondition;
 
-    std::vector<std::weak_ptr<ASensorEventQueue>> mReadyQueues;
+    std::set<android::wp<ASensorEventQueue>> mReadyQueues;
     bool mAwoken;
 
     DISALLOW_COPY_AND_ASSIGN(ALooper);
diff --git a/sensorservice/libsensorndkbridge/ASensorEventQueue.cpp b/sensorservice/libsensorndkbridge/ASensorEventQueue.cpp
index 2969da1..bf24f68 100644
--- a/sensorservice/libsensorndkbridge/ASensorEventQueue.cpp
+++ b/sensorservice/libsensorndkbridge/ASensorEventQueue.cpp
@@ -20,12 +20,14 @@
 
 #define LOG_TAG "libsensorndkbridge"
 #include <android-base/logging.h>
-#include <android/binder_auto_utils.h>
 
-using aidl::android::hardware::sensors::SensorInfo;
+using android::sp;
+using android::frameworks::sensorservice::V1_0::Result;
+using android::hardware::sensors::V1_0::SensorInfo;
+using android::OK;
 using android::BAD_VALUE;
 using android::Mutex;
-using android::OK;
+using android::hardware::Return;
 
 ASensorEventQueue::ASensorEventQueue(ALooper* looper, ALooper_callbackFunc callback, void* data)
     : mLooper(looper),
@@ -34,7 +36,7 @@
       mRequestAdditionalInfo(false),
       mValid(true) {}
 
-void ASensorEventQueue::setImpl(const std::shared_ptr<IEventQueue>& queueImpl) {
+void ASensorEventQueue::setImpl(const sp<IEventQueue> &queueImpl) {
     mQueueImpl = queueImpl;
 }
 
@@ -42,9 +44,10 @@
         ASensorRef sensor,
         int32_t samplingPeriodUs,
         int64_t maxBatchReportLatencyUs) {
-    ndk::ScopedAStatus ret =
-        mQueueImpl->enableSensor(reinterpret_cast<const SensorInfo*>(sensor)->sensorHandle,
-                                 samplingPeriodUs, maxBatchReportLatencyUs);
+    Return<Result> ret = mQueueImpl->enableSensor(
+            reinterpret_cast<const SensorInfo *>(sensor)->sensorHandle,
+            samplingPeriodUs,
+            maxBatchReportLatencyUs);
 
     if (!ret.isOk()) {
         return BAD_VALUE;
@@ -74,8 +77,8 @@
 }
 
 int ASensorEventQueue::disableSensor(ASensorRef sensor) {
-    ndk::ScopedAStatus ret =
-        mQueueImpl->disableSensor(reinterpret_cast<const SensorInfo*>(sensor)->sensorHandle);
+    Return<Result> ret = mQueueImpl->disableSensor(
+            reinterpret_cast<const SensorInfo *>(sensor)->sensorHandle);
 
     return ret.isOk() ? OK : BAD_VALUE;
 }
@@ -103,7 +106,7 @@
     return !mQueue.empty();
 }
 
-ndk::ScopedAStatus ASensorEventQueue::onEvent(const Event& event) {
+Return<void> ASensorEventQueue::onEvent(const Event &event) {
     LOG(VERBOSE) << "ASensorEventQueue::onEvent";
 
     if (static_cast<int32_t>(event.sensorType) != ASENSOR_TYPE_ADDITIONAL_INFO ||
@@ -124,16 +127,17 @@
             Mutex::Autolock autoLock(mLock);
             mQueue.emplace_back();
             sensors_event_t* sensorEvent = &mQueue[mQueue.size() - 1];
-            android::hardware::sensors::implementation::convertToSensorEvent(event, sensorEvent);
+            android::hardware::sensors::V1_0::implementation::convertToSensorEvent(event,
+                                                                                   sensorEvent);
         }
 
         Mutex::Autolock autoLock(mValidLock);
         if (mValid) {
-            mLooper->signalSensorEvents(this->ref<ASensorEventQueue>());
+            mLooper->signalSensorEvents(this);
         }
     }
 
-    return ndk::ScopedAStatus::ok();
+    return android::hardware::Void();
 }
 
 void ASensorEventQueue::dispatchCallback() {
@@ -155,7 +159,7 @@
       Mutex::Autolock autoLock(mValidLock);
       mValid = false;
     }
-    mLooper->invalidateSensorQueue(this->ref<ASensorEventQueue>());
+    mLooper->invalidateSensorQueue(this);
     setImpl(nullptr);
 }
 
diff --git a/sensorservice/libsensorndkbridge/ASensorEventQueue.h b/sensorservice/libsensorndkbridge/ASensorEventQueue.h
index 6c7f5c4..7139d34 100644
--- a/sensorservice/libsensorndkbridge/ASensorEventQueue.h
+++ b/sensorservice/libsensorndkbridge/ASensorEventQueue.h
@@ -18,32 +18,31 @@
 
 #define A_SENSOR_EVENT_QUEUE_H_
 
-#include <aidl/android/frameworks/sensorservice/BnEventQueueCallback.h>
-#include <aidl/android/frameworks/sensorservice/IEventQueue.h>
-#include <aidl/sensors/convert.h>
-#include <android-base/macros.h>
-#include <android/binder_auto_utils.h>
+#include <android/frameworks/sensorservice/1.0/IEventQueue.h>
+#include <android/frameworks/sensorservice/1.0/IEventQueueCallback.h>
 #include <android/looper.h>
 #include <android/sensor.h>
+#include <android-base/macros.h>
+#include <sensors/convert.h>
 #include <utils/Mutex.h>
-#include <utils/RefBase.h>
 
 #include <atomic>
 
 struct ALooper;
 
-struct ASensorEventQueue : public aidl::android::frameworks::sensorservice::BnEventQueueCallback {
-    using Event = aidl::android::hardware::sensors::Event;
-    using IEventQueue = aidl::android::frameworks::sensorservice::IEventQueue;
+struct ASensorEventQueue
+    : public android::frameworks::sensorservice::V1_0::IEventQueueCallback {
+    using Event = android::hardware::sensors::V1_0::Event;
+    using IEventQueue = android::frameworks::sensorservice::V1_0::IEventQueue;
 
     ASensorEventQueue(
             ALooper *looper,
             ALooper_callbackFunc callback,
             void *data);
 
-    ndk::ScopedAStatus onEvent(const Event& event) override;
+    android::hardware::Return<void> onEvent(const Event &event) override;
 
-    void setImpl(const std::shared_ptr<IEventQueue>& queueImpl);
+    void setImpl(const android::sp<IEventQueue> &queueImpl);
 
     int registerSensor(
             ASensorRef sensor,
@@ -68,7 +67,7 @@
     ALooper *mLooper;
     ALooper_callbackFunc mCallback;
     void *mData;
-    std::shared_ptr<IEventQueue> mQueueImpl;
+    android::sp<IEventQueue> mQueueImpl;
 
     android::Mutex mLock;
     std::vector<sensors_event_t> mQueue;
diff --git a/sensorservice/libsensorndkbridge/ASensorManager.cpp b/sensorservice/libsensorndkbridge/ASensorManager.cpp
index c8dca89..de552e0 100644
--- a/sensorservice/libsensorndkbridge/ASensorManager.cpp
+++ b/sensorservice/libsensorndkbridge/ASensorManager.cpp
@@ -19,23 +19,25 @@
 #include "ASensorManager.h"
 
 #define LOG_TAG "libsensorndkbridge"
-#include <aidl/sensors/convert.h>
 #include <android-base/logging.h>
-#include <android/binder_auto_utils.h>
-#include <android/binder_ibinder_platform.h>
-#include <android/binder_manager.h>
-#include <android/binder_process.h>
 #include <android/looper.h>
+#include <hidl/HidlTransportSupport.h>
+#include <sensors/convert.h>
 
-using aidl::android::frameworks::sensorservice::IEventQueue;
-using aidl::android::frameworks::sensorservice::ISensorManager;
-using aidl::android::hardware::sensors::SensorInfo;
-using aidl::android::hardware::sensors::SensorType;
-using android::BAD_VALUE;
+using android::hardware::sensors::V1_0::SensorInfo;
+using android::frameworks::sensorservice::V1_0::IEventQueue;
+using android::frameworks::sensorservice::V1_0::ISensorManager;
+using android::frameworks::sensorservice::V1_0::Result;
+using android::hardware::sensors::V1_0::SensorType;
+using android::sp;
+using android::wp;
 using android::Mutex;
-using android::NO_INIT;
-using android::OK;
 using android::status_t;
+using android::OK;
+using android::NO_INIT;
+using android::BAD_VALUE;
+using android::hardware::hidl_vec;
+using android::hardware::Return;
 
 static Mutex gLock;
 
@@ -55,7 +57,8 @@
     return sInstance;
 }
 
-void ASensorManager::serviceDied(void*) {
+void ASensorManager::SensorDeathRecipient::serviceDied(
+        uint64_t, const wp<::android::hidl::base::V1_0::IBase>&) {
     LOG(ERROR) << "Sensor service died. Cleanup sensor manager instance!";
     Mutex::Autolock autoLock(gLock);
     delete sInstance;
@@ -64,17 +67,14 @@
 
 ASensorManager::ASensorManager()
     : mInitCheck(NO_INIT) {
-    ABinderProcess_setThreadPoolMaxThreadCount(1);
-    ABinderProcess_startThreadPool();
-    const std::string name = std::string() + ISensorManager::descriptor + "/default";
-    mManager =
-        ISensorManager::fromBinder(ndk::SpAIBinder(AServiceManager_waitForService(name.c_str())));
+    mManager = ISensorManager::getService();
     if (mManager != NULL) {
-        mDeathRecipient =
-            ndk::ScopedAIBinder_DeathRecipient(AIBinder_DeathRecipient_new(serviceDied));
-        auto linked =
-            AIBinder_linkToDeath(mManager->asBinder().get(), mDeathRecipient.get(), nullptr);
-        if (linked != OK) {
+        mDeathRecipient = new SensorDeathRecipient();
+        Return<bool> linked = mManager->linkToDeath(mDeathRecipient, /*cookie*/ 0);
+        if (!linked.isOk()) {
+            LOG(ERROR) << "Transaction error in linking to sensor service death: " <<
+                    linked.description().c_str();
+        } else if (!linked) {
             LOG(WARNING) << "Unable to link to sensor service death notifications";
         } else {
             LOG(DEBUG) << "Link to sensor service death notification successful";
@@ -93,11 +93,16 @@
     Mutex::Autolock autoLock(mLock);
 
     if (mSensorList == NULL) {
-        ndk::ScopedAStatus ret = mManager->getSensorList(&mSensors);
+        Return<void> ret =
+            mManager->getSensorList([&](const auto &list, auto result) {
+                if (result != Result::OK) {
+                    return;
+                }
 
-        if (!ret.isOk()) {
-            LOG(ERROR) << "Failed to get sensor list: " << ret;
-        }
+                mSensors = list;
+        });
+
+        (void)ret.isOk();
 
         mSensorList.reset(new ASensorRef[mSensors.size()]);
         for (size_t i = 0; i < mSensors.size(); ++i) {
@@ -118,21 +123,24 @@
 
     ASensorRef defaultSensor = NULL;
 
-    SensorInfo sensor;
+    Return<void> ret = mManager->getDefaultSensor(
+            static_cast<SensorType>(type),
+            [&](const auto &sensor, auto result) {
+                if (result != Result::OK) {
+                    return;
+                }
 
-    ndk::ScopedAStatus ret = mManager->getDefaultSensor(static_cast<SensorType>(type), &sensor);
+                for (size_t i = 0; i < mSensors.size(); ++i) {
+                    if (sensor == mSensors[i]) {
+                        defaultSensor =
+                             reinterpret_cast<ASensorRef>(&mSensors[i]);
 
-    if (!ret.isOk()) {
-        LOG(ERROR) << "Failed to get default sensor of type " << type << " with error: " << ret;
-    }
+                        break;
+                    }
+                }
+            });
 
-    for (size_t i = 0; i < mSensors.size(); ++i) {
-        if (sensor == mSensors[i]) {
-            defaultSensor = reinterpret_cast<ASensorRef>(&mSensors[i]);
-
-            break;
-        }
-    }
+    (void)ret.isOk();
 
     return defaultSensor;
 }
@@ -150,23 +158,28 @@
         void *data) {
     LOG(VERBOSE) << "ASensorManager::createEventQueue";
 
-    std::shared_ptr<ASensorEventQueue> queue =
-        ndk::SharedRefBase::make<ASensorEventQueue>(looper, callback, data);
+    sp<ASensorEventQueue> queue =
+        new ASensorEventQueue(looper, callback, data);
 
-    AIBinder_setMinSchedulerPolicy(queue->asBinder().get(), SCHED_FIFO, 98);
-    std::shared_ptr<IEventQueue> eventQueue;
-    ndk::ScopedAStatus ret = mManager->createEventQueue(queue, &eventQueue);
+    ::android::hardware::setMinSchedulerPolicy(queue, SCHED_FIFO, 98);
+    Result result;
+    Return<void> ret =
+        mManager->createEventQueue(
+                queue, [&](const sp<IEventQueue> &queueImpl, auto tmpResult) {
+                    result = tmpResult;
+                    if (result != Result::OK) {
+                        return;
+                    }
 
-    if (!ret.isOk()) {
-        LOG(ERROR) << "FAILED to create event queue: " << ret;
+                    queue->setImpl(queueImpl);
+                });
+
+    if (!ret.isOk() || result != Result::OK) {
+        LOG(ERROR) << "FAILED to create event queue";
         return NULL;
     }
-    queue->setImpl(eventQueue);
 
-    {
-        Mutex::Autolock autoLock(mQueuesLock);
-        mQueues.push_back(queue);
-    }
+    queue->incStrong(NULL /* id */);
 
     LOG(VERBOSE) << "Returning event queue " << queue.get();
     return queue.get();
@@ -177,14 +190,8 @@
 
     queue->invalidate();
 
-    {
-        Mutex::Autolock autoLock(mQueuesLock);
-        mQueues.erase(std::remove_if(mQueues.begin(), mQueues.end(),
-                                     [&](const std::shared_ptr<ASensorEventQueue>& ptr) {
-                                         return ptr.get() == queue;
-                                     }),
-                      mQueues.end());
-    }
+    queue->decStrong(NULL /* id */);
+    queue = NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -367,7 +374,7 @@
 
 int ASensor_getMinDelay(ASensor const* sensor) {
     RETURN_IF_SENSOR_IS_NULL(ASENSOR_DELAY_INVALID);
-    return reinterpret_cast<const SensorInfo*>(sensor)->minDelayUs;
+    return reinterpret_cast<const SensorInfo *>(sensor)->minDelay;
 }
 
 int ASensor_getFifoMaxEventCount(ASensor const* sensor) {
diff --git a/sensorservice/libsensorndkbridge/ASensorManager.h b/sensorservice/libsensorndkbridge/ASensorManager.h
index e45cbfe..4e91122 100644
--- a/sensorservice/libsensorndkbridge/ASensorManager.h
+++ b/sensorservice/libsensorndkbridge/ASensorManager.h
@@ -18,8 +18,8 @@
 
 #define A_SENSOR_MANAGER_H_
 
-#include <aidl/android/frameworks/sensorservice/ISensorManager.h>
 #include <android-base/macros.h>
+#include <android/frameworks/sensorservice/1.0/ISensorManager.h>
 #include <android/sensor.h>
 #include <utils/Mutex.h>
 #include <utils/RefBase.h>
@@ -48,23 +48,26 @@
     // ALooper.
     void destroyEventQueue(ASensorEventQueue *queue);
 
-    static void serviceDied(void* cookie);
+private:
 
-   private:
-    using ISensorManager = aidl::android::frameworks::sensorservice::ISensorManager;
-    using SensorInfo = aidl::android::hardware::sensors::SensorInfo;
+    struct SensorDeathRecipient : public android::hardware::hidl_death_recipient
+    {
+        // hidl_death_recipient interface
+        virtual void serviceDied(uint64_t cookie,
+                const ::android::wp<::android::hidl::base::V1_0::IBase>& who) override;
+    };
+
+    using ISensorManager = android::frameworks::sensorservice::V1_0::ISensorManager;
+    using SensorInfo = android::hardware::sensors::V1_0::SensorInfo;
 
     static ASensorManager *sInstance;
-    ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
+    android::sp<SensorDeathRecipient> mDeathRecipient = nullptr;
 
     android::status_t mInitCheck;
-    std::shared_ptr<ISensorManager> mManager;
-
-    mutable android::Mutex mQueuesLock;
-    std::vector<std::shared_ptr<ASensorEventQueue>> mQueues;
+    android::sp<ISensorManager> mManager;
 
     mutable android::Mutex mLock;
-    std::vector<SensorInfo> mSensors;
+    android::hardware::hidl_vec<SensorInfo> mSensors;
     std::unique_ptr<ASensorRef[]> mSensorList;
 
     DISALLOW_COPY_AND_ASSIGN(ASensorManager);
diff --git a/sensorservice/libsensorndkbridge/Android.bp b/sensorservice/libsensorndkbridge/Android.bp
index 6fadeff..33b9619 100644
--- a/sensorservice/libsensorndkbridge/Android.bp
+++ b/sensorservice/libsensorndkbridge/Android.bp
@@ -24,19 +24,16 @@
         "ASensorEventQueue.cpp",
         "ASensorManager.cpp",
     ],
-    cflags: [
-        "-Wall",
-        "-Werror",
-    ],
+    cflags: ["-Wall", "-Werror"],
     shared_libs: [
         "libbase",
-        "libbinder_ndk",
+        "libhidlbase",
         "libutils",
-        "android.frameworks.sensorservice-V1-ndk",
-        "android.hardware.sensors-V1-ndk",
+        "android.frameworks.sensorservice@1.0",
+        "android.hardware.sensors@1.0",
     ],
     static_libs: [
-        "android.hardware.sensors-V1-convert",
+        "android.hardware.sensors@1.0-convert",
     ],
 
     header_libs: [
@@ -46,11 +43,4 @@
     export_header_lib_headers: [
         "libandroid_sensor_headers",
     ],
-
-    export_shared_lib_headers: [
-        "android.frameworks.sensorservice-V1-ndk",
-    ],
-    export_static_lib_headers: [
-        "android.hardware.sensors-V1-convert",
-    ],
 }