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

Commit 468f8067 authored by Lais Andrade's avatar Lais Andrade
Browse files

Add manager controller to Android.bp 

The vibrator manager controller introduced in a previous change was not
added to the build and test targets. Adding them now, with some fixed to
the header and cpp files.

Bug: 167946816
Test: atest libvibratorservice_test
Change-Id: I6601c50269b298aadc67fa96eea30733ac4a67c7
parent 7e2bbfa2

services/vibratorservice/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ cc_library_shared { 
        "VibratorCallbackScheduler.cpp",

        "VibratorHalController.cpp",

        "VibratorHalWrapper.cpp",

        "VibratorManagerHalController.cpp",

        "VibratorManagerHalWrapper.cpp",

    ],

services/vibratorservice/VibratorManagerHalController.cpp

+3 −4
Original line number Diff line number Diff line
@@ -26,13 +26,13 @@ namespace android { 


namespace vibrator {



std::shared_ptr<ManagerHalWrapper> connectHal(std::shared_ptr<CallbackScheduler> scheduler) {

std::shared_ptr<ManagerHalWrapper> connectManagerHal(std::shared_ptr<CallbackScheduler> scheduler) {

    static bool gHalExists = true;

    if (gHalExists) {

        sp<Aidl::IVibratorManager> hal = waitForVintfService<Aidl::IVibratorManager>();

        if (hal) {

            ALOGV("Successfully connected to VibratorManager HAL AIDL service.");

            return std::make_shared<AidlManagerHalWrapper>(std::move(scheduler), aidlHal);

            return std::make_shared<AidlManagerHalWrapper>(std::move(scheduler), hal);

        }

    }
@@ -80,12 +80,11 @@ HalResult<T> ManagerHalController::apply(ManagerHalController::hal_fn<T>& halFn, 


// -------------------------------------------------------------------------------------------------



bool ManagerHalController::init() {

void ManagerHalController::init() {

    std::lock_guard<std::mutex> lock(mConnectedHalMutex);

    if (mConnectedHal == nullptr) {

        mConnectedHal = mConnector(mCallbackScheduler);

    }

    return mConnectedHal != nullptr;

}



HalResult<void> ManagerHalController::ping() {

services/vibratorservice/include/vibratorservice/VibratorManagerHalController.h

+4 −2
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#include <android/hardware/vibrator/IVibratorManager.h>

#include <vibratorservice/VibratorHalController.h>

#include <vibratorservice/VibratorManagerHalWrapper.h>

#include <unordered_map>



namespace android {
@@ -36,7 +37,7 @@ public: 
    ManagerHalController()

          : ManagerHalController(std::make_shared<CallbackScheduler>(), &connectManagerHal) {}

    ManagerHalController(std::shared_ptr<CallbackScheduler> callbackScheduler, Connector connector)

          : mConnector(connector), mConnectedHal(nullptr) {}

          : mConnector(connector), mCallbackScheduler(callbackScheduler), mConnectedHal(nullptr) {}

    virtual ~ManagerHalController() = default;



    /* Connects to the HAL service, possibly waiting for the registered service to
@@ -64,9 +65,10 @@ public: 


private:

    Connector mConnector;

    std::shared_ptr<CallbackScheduler> mCallbackScheduler;

    std::mutex mConnectedHalMutex;

    // Shared pointer to allow local copies to be used by different threads.

    std::shared_ptr<HalWrapper> mConnectedHal GUARDED_BY(mConnectedHalMutex);

    std::shared_ptr<ManagerHalWrapper> mConnectedHal GUARDED_BY(mConnectedHalMutex);



    template <typename T>

    HalResult<T> processHalResult(HalResult<T> result, const char* functionName);

services/vibratorservice/test/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ cc_test { 
        "VibratorHalWrapperHidlV1_1Test.cpp",

        "VibratorHalWrapperHidlV1_2Test.cpp",

        "VibratorHalWrapperHidlV1_3Test.cpp",

        "VibratorManagerHalControllerTest.cpp",

        "VibratorManagerHalWrapperAidlTest.cpp",

        "VibratorManagerHalWrapperLegacyTest.cpp",

    ],

services/vibratorservice/test/VibratorManagerHalControllerTest.cpp

+34 −37
Original line number Diff line number Diff line
@@ -22,22 +22,28 @@ 


#include <utils/Log.h>



#include <vibratorservice/VibratorManagerHalWrapper.h>

#include <vibratorservice/VibratorManagerHalController.h>



#include "test_utils.h"



using android::vibrator::HalController;



using namespace android;

using namespace testing;



static constexpr int MAX_ATTEMPTS = 2;

static const std::vector<int32_t> VIBRATOR_IDS = {1, 2};

static constexpr int VIBRATOR_ID = 1;



class MockManagerHalWrapper : public vibrator::ManagerHalWrapper {

public:

    MOCK_METHOD(void, tryReconnect, (), (override));

    MOCK_METHOD(vibrator::HalResult<void>, ping, (), (override));

    MOCK_METHOD(vibrator::HalResult<int32_t>, getCapabilities, (), (override));

    MOCK_METHOD(vibrator::HalResult<vibrator::ManagerCapabilities>, getCapabilities, (),

                (override));

    MOCK_METHOD(vibrator::HalResult<std::vector<int32_t>>, getVibratorIds, (), (override));

    MOCK_METHOD(vibrator::HalResult<std::shared_ptr<vibrator::HalController>>, getVibrator,

                (int32_t id), (override));

    MOCK_METHOD(vibrator::HalResult<std::shared_ptr<HalController>>, getVibrator, (int32_t id),

                (override));

    MOCK_METHOD(vibrator::HalResult<void>, prepareSynced, (const std::vector<int32_t>& ids),

                (override));

    MOCK_METHOD(vibrator::HalResult<void>, triggerSynced,
@@ -50,13 +56,13 @@ public: 
    void SetUp() override {

        mConnectCounter = 0;

        auto callbackScheduler = std::make_shared<vibrator::CallbackScheduler>();

        mMockHal = std::make_shared<StrictMock<MockHalWrapper>>(callbackScheduler);

        mController = std::make_unique<

                vibrator::HalController>(std::move(callbackScheduler),

                                         [&](std::shared_ptr<vibrator::CallbackScheduler>) {

                                             android_atomic_inc(&(this->mConnectCounter));

                                             return this->mMockHal;

                                         });

        mMockHal = std::make_shared<StrictMock<MockManagerHalWrapper>>();

        auto connector = [this](std::shared_ptr<vibrator::CallbackScheduler>) {

            android_atomic_inc(&mConnectCounter);

            return mMockHal;

        };

        mController = std::make_unique<vibrator::ManagerHalController>(std::move(callbackScheduler),

                                                                       connector);

        ASSERT_NE(mController, nullptr);

    }
@@ -65,8 +71,7 @@ protected: 
    std::shared_ptr<MockManagerHalWrapper> mMockHal;

    std::unique_ptr<vibrator::ManagerHalController> mController;



    void setHalExpectations(int32_t cardinality, std::vector<int32_t> ids,

                            vibrator::HalResult<void> voidResult,

    void setHalExpectations(int32_t cardinality, vibrator::HalResult<void> voidResult,

                            vibrator::HalResult<vibrator::ManagerCapabilities> capabilitiesResult,

                            vibrator::HalResult<std::vector<int32_t>> idsResult,

                            vibrator::HalResult<std::shared_ptr<HalController>> vibratorResult) {
@@ -100,24 +105,20 @@ protected: 
};



TEST_F(VibratorManagerHalControllerTest, TestInit) {

    ASSERT_TRUE(mController->init());

    mController->init();

    ASSERT_EQ(1, mConnectCounter);



    // Noop when wrapper was already initialized.

    ASSERT_TRUE(mController->init());

    mController->init();

    ASSERT_EQ(1, mConnectCounter);

}



TEST_F(VibratorManagerHalControllerTest, TestApiCallsAreForwardedToHal) {

    std::vector<int32_t> ids;

    ids.push_back(1);

    ids.push_back(2);



    setHalExpectations(/* cardinality= */ 1, ids, vibrator::HalResult<void>::ok(),

    setHalExpectations(/* cardinality= */ 1, vibrator::HalResult<void>::ok(),

                       vibrator::HalResult<vibrator::ManagerCapabilities>::ok(

                               vibrator::ManagerCapabilities::SYNC),

                       vibrator::HalResult<std::vector<int32_t>>::ok(ids),

                       vibrator::HalResult<std::shared_ptr<vibrator::HalController>>::ok(nullptr));

                       vibrator::HalResult<std::vector<int32_t>>::ok(VIBRATOR_IDS),

                       vibrator::HalResult<std::shared_ptr<HalController>>::ok(nullptr));



    ASSERT_TRUE(mController->ping().isOk());
@@ -127,13 +128,13 @@ TEST_F(VibratorManagerHalControllerTest, TestApiCallsAreForwardedToHal) { 


    auto getVibratorIdsResult = mController->getVibratorIds();

    ASSERT_TRUE(getVibratorIdsResult.isOk());

    ASSERT_EQ(ids, getVibratorIdsResult.value());

    ASSERT_EQ(VIBRATOR_IDS, getVibratorIdsResult.value());



    auto getVibratorResult = mController->getVibrator(1);

    auto getVibratorResult = mController->getVibrator(VIBRATOR_ID);

    ASSERT_TRUE(getVibratorResult.isOk());

    ASSERT_EQ(nullptr, getVibratorResult.value());



    ASSERT_TRUE(mController->prepareSynced(ids).isOk());

    ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isOk());

    ASSERT_TRUE(mController->triggerSynced([]() {}).isOk());

    ASSERT_TRUE(mController->cancelSynced().isOk());
@@ -141,20 +142,18 @@ TEST_F(VibratorManagerHalControllerTest, TestApiCallsAreForwardedToHal) { 
}



TEST_F(VibratorManagerHalControllerTest, TestUnsupportedApiResultDoNotResetHalConnection) {

    std::vector<int32_t> ids;

    setHalExpectations(/* cardinality= */ 1, ids, vibrator::HalResult<void>::unsupported(),

    setHalExpectations(/* cardinality= */ 1, vibrator::HalResult<void>::unsupported(),

                       vibrator::HalResult<vibrator::ManagerCapabilities>::unsupported(),

                       vibrator::HalResult<std::vector<int32_t>>::unsupported(),

                       vibrator::HalResult<

                               std::shared_ptr<vibrator::HalController>>::unsupported());

                       vibrator::HalResult<std::shared_ptr<HalController>>::unsupported());



    ASSERT_EQ(0, mConnectCounter);



    ASSERT_TRUE(mController->ping().isUnsupported());

    ASSERT_TRUE(mController->getCapabilities().isUnsupported());

    ASSERT_TRUE(mController->getVibratorIds().isUnsupported());

    ASSERT_TRUE(mController->getVibrator(1).isUnsupported());

    ASSERT_TRUE(mController->prepareSynced(ids).isUnsupported());

    ASSERT_TRUE(mController->getVibrator(VIBRATOR_ID).isUnsupported());

    ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isUnsupported());

    ASSERT_TRUE(mController->triggerSynced([]() {}).isUnsupported());

    ASSERT_TRUE(mController->cancelSynced().isUnsupported());
@@ -162,20 +161,18 @@ TEST_F(VibratorManagerHalControllerTest, TestUnsupportedApiResultDoNotResetHalCo 
}



TEST_F(VibratorManagerHalControllerTest, TestFailedApiResultResetsHalConnection) {

    std::vector<int32_t> ids;

    setHalExpectations(/* cardinality= */ 1, ids, vibrator::HalResult<void>::failed("message"),

    setHalExpectations(MAX_ATTEMPTS, vibrator::HalResult<void>::failed("message"),

                       vibrator::HalResult<vibrator::ManagerCapabilities>::failed("message"),

                       vibrator::HalResult<std::vector<int32_t>>::failed("message"),

                       vibrator::HalResult<std::shared_ptr<vibrator::HalController>>::failed(

                               "message"));

                       vibrator::HalResult<std::shared_ptr<HalController>>::failed("message"));



    ASSERT_EQ(0, mConnectCounter);



    ASSERT_TRUE(mController->ping().isFailed());

    ASSERT_TRUE(mController->getCapabilities().isFailed());

    ASSERT_TRUE(mController->getVibratorIds().isFailed());

    ASSERT_TRUE(mController->getVibrator(1).isFailed());

    ASSERT_TRUE(mController->prepareSynced(ids).isFailed());

    ASSERT_TRUE(mController->getVibrator(VIBRATOR_ID).isFailed());

    ASSERT_TRUE(mController->prepareSynced(VIBRATOR_IDS).isFailed());

    ASSERT_TRUE(mController->triggerSynced([]() {}).isFailed());

    ASSERT_TRUE(mController->cancelSynced().isFailed());