Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc0f9b7a authored by Ytai Ben-tsvi's avatar Ytai Ben-tsvi Committed by Android (Google) Code Review
Browse files

Merge "Remove dependency on libandroid" into sc-v2-dev

parents a9382770 9f12f178

media/libheadtracking/Android.bp

+1 −2
Original line number Diff line number Diff line
@@ -38,9 +38,9 @@ cc_library { 
    ],

    shared_libs: [

        "libheadtracking",

        "libandroid",

        "liblog",

        "libsensor",

        "libutils",

    ],

    export_shared_lib_headers: [

        "libheadtracking",
@@ -53,7 +53,6 @@ cc_binary { 
        "SensorPoseProvider-example.cpp",

    ],

    shared_libs: [

        "libandroid",

        "libheadtracking",

        "libheadtracking-binding",

        "libsensor",

media/libheadtracking/SensorPoseProvider-example.cpp

+12 −11
Original line number Diff line number Diff line
@@ -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 @@ class Listener : public SensorPoseProvider::Listener { 
};



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

media/libheadtracking/SensorPoseProvider.cpp

+52 −43
Original line number Diff line number Diff line
@@ -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 android { 
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 EventQueueGuard { 
 */

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 @@ class SensorEnableGuard { 


    // 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 @@ class SensorPoseProviderImpl : public SensorPoseProvider { 
    ~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 @@ class SensorPoseProviderImpl : public SensorPoseProvider { 


    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 @@ class SensorPoseProviderImpl : public SensorPoseProvider { 
            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 @@ class SensorPoseProviderImpl : public SensorPoseProvider { 
                    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) {

media/libheadtracking/include/media/SensorPoseProvider.h

+3 −6
Original line number Diff line number Diff line
@@ -81,17 +81,14 @@ class SensorPoseProvider { 
     * @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;

};

services/audiopolicy/service/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ cc_library_shared { 


    shared_libs: [

        "libactivitymanager_aidl",

        "libandroid",

        "libaudioclient",

        "libaudioclient_aidl_conversion",

        "libaudiofoundation",