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

Commit 49b60b15 authored by Lais Andrade's avatar Lais Andrade
Browse files

Return duration for composed effects. 

Use IVibrator.getPrimitiveDuration to calculate the duration a composed
effect should have and return this result to the service.

Bug: 177807015
Test: atest libvibratorservice_test
Change-Id: I606fdb59818a13e138e1cde36172ea74050a8a75
parent 01833ba2

services/vibratorservice/VibratorHalController.cpp

+2 −2
Original line number Diff line number Diff line
@@ -217,10 +217,10 @@ HalResult<milliseconds> HalController::performEffect( 
    return apply(performEffectFn, "performEffect");

}



HalResult<void> HalController::performComposedEffect(

HalResult<milliseconds> HalController::performComposedEffect(

        const std::vector<CompositeEffect>& primitiveEffects,

        const std::function<void()>& completionCallback) {

    hal_fn<void> performComposedEffectFn = [&](std::shared_ptr<HalWrapper> hal) {

    hal_fn<milliseconds> performComposedEffectFn = [&](std::shared_ptr<HalWrapper> hal) {

        return hal->performComposedEffect(primitiveEffects, completionCallback);

    };

    return apply(performComposedEffectFn, "performComposedEffect");

services/vibratorservice/VibratorHalWrapper.cpp

+38 −5
Original line number Diff line number Diff line
@@ -224,12 +224,45 @@ HalResult<milliseconds> AidlHalWrapper::performEffect( 
    return ret;

}



HalResult<void> AidlHalWrapper::performComposedEffect(

HalResult<milliseconds> AidlHalWrapper::performComposedEffect(

        const std::vector<CompositeEffect>& primitiveEffects,

        const std::function<void()>& completionCallback) {

    // This method should always support callbacks, so no need to double check.

    auto cb = new HalCallbackWrapper(completionCallback);

    return HalResult<void>::fromStatus(getHal()->compose(primitiveEffects, cb));

    milliseconds duration(0);

    for (const auto& effect : primitiveEffects) {

        auto durationResult = getPrimitiveDuration(effect.primitive);

        if (durationResult.isOk()) {

            duration += durationResult.value();

        }

        duration += milliseconds(effect.delayMs);

    }

    return HalResult<milliseconds>::fromStatus(getHal()->compose(primitiveEffects, cb), duration);

}



HalResult<milliseconds> AidlHalWrapper::getPrimitiveDuration(CompositePrimitive primitive) {

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

    if (mPrimitiveDurations.empty()) {

        constexpr auto primitiveRange = enum_range<CompositePrimitive>();

        constexpr auto primitiveCount = std::distance(primitiveRange.begin(), primitiveRange.end());

        mPrimitiveDurations.resize(primitiveCount);

    }

    auto primitiveIdx = static_cast<size_t>(primitive);

    if (primitiveIdx >= mPrimitiveDurations.size()) {

        // Safety check, should not happen if enum_range is correct.

        return HalResult<milliseconds>::unsupported();

    }

    auto& cache = mPrimitiveDurations[primitiveIdx];

    if (cache.has_value()) {

        return HalResult<milliseconds>::ok(*cache);

    }

    int32_t duration;

    auto result = getHal()->getPrimitiveDuration(primitive, &duration);

    if (result.isOk()) {

        // Cache copy of returned value.

        cache.emplace(duration);

    }

    return HalResult<milliseconds>::fromStatus(result, milliseconds(duration));

}



HalResult<Capabilities> AidlHalWrapper::getCapabilitiesInternal() {
@@ -333,10 +366,10 @@ HalResult<std::vector<CompositePrimitive>> HidlHalWrapper<I>::getSupportedPrimit 
}



template <typename I>

HalResult<void> HidlHalWrapper<I>::performComposedEffect(const std::vector<CompositeEffect>&,

                                                         const std::function<void()>&) {

HalResult<std::chrono::milliseconds> HidlHalWrapper<I>::performComposedEffect(

        const std::vector<CompositeEffect>&, const std::function<void()>&) {

    ALOGV("Skipped composed effect because Vibrator HAL AIDL is not available");

    return HalResult<void>::unsupported();

    return HalResult<std::chrono::milliseconds>::unsupported();

}



template <typename I>

services/vibratorservice/include/vibratorservice/VibratorHalController.h

+1 −1
Original line number Diff line number Diff line
@@ -77,7 +77,7 @@ public: 
            hardware::vibrator::Effect effect, hardware::vibrator::EffectStrength strength,

            const std::function<void()>& completionCallback) final override;



    HalResult<void> performComposedEffect(

    HalResult<std::chrono::milliseconds> performComposedEffect(

            const std::vector<hardware::vibrator::CompositeEffect>& primitiveEffects,

            const std::function<void()>& completionCallback) final override;

services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h

+9 −3
Original line number Diff line number Diff line
@@ -189,7 +189,7 @@ public: 
            hardware::vibrator::Effect effect, hardware::vibrator::EffectStrength strength,

            const std::function<void()>& completionCallback) = 0;



    virtual HalResult<void> performComposedEffect(

    virtual HalResult<std::chrono::milliseconds> performComposedEffect(

            const std::vector<hardware::vibrator::CompositeEffect>& primitiveEffects,

            const std::function<void()>& completionCallback) = 0;
@@ -236,7 +236,7 @@ public: 
            hardware::vibrator::Effect effect, hardware::vibrator::EffectStrength strength,

            const std::function<void()>& completionCallback) override final;



    HalResult<void> performComposedEffect(

    HalResult<std::chrono::milliseconds> performComposedEffect(

            const std::vector<hardware::vibrator::CompositeEffect>& primitiveEffects,

            const std::function<void()>& completionCallback) override final;
@@ -252,6 +252,12 @@ private: 
            GUARDED_BY(mSupportedEffectsMutex);

    std::optional<std::vector<hardware::vibrator::CompositePrimitive>> mSupportedPrimitives

            GUARDED_BY(mSupportedPrimitivesMutex);

    std::vector<std::optional<std::chrono::milliseconds>> mPrimitiveDurations

            GUARDED_BY(mSupportedPrimitivesMutex);



    // Loads and caches from IVibrator.

    HalResult<std::chrono::milliseconds> getPrimitiveDuration(

            hardware::vibrator::CompositePrimitive primitive);



    // Loads directly from IVibrator handle, skipping caches.

    HalResult<Capabilities> getCapabilitiesInternal();
@@ -287,7 +293,7 @@ public: 
    HalResult<std::vector<hardware::vibrator::CompositePrimitive>> getSupportedPrimitives()

            override final;



    HalResult<void> performComposedEffect(

    HalResult<std::chrono::milliseconds> performComposedEffect(

            const std::vector<hardware::vibrator::CompositeEffect>& primitiveEffects,

            const std::function<void()>& completionCallback) override final;

services/vibratorservice/test/VibratorHalControllerTest.cpp

+6 −3
Original line number Diff line number Diff line
@@ -71,7 +71,7 @@ public: 
                (Effect effect, EffectStrength strength,

                 const std::function<void()>& completionCallback),

                (override));

    MOCK_METHOD(vibrator::HalResult<void>, performComposedEffect,

    MOCK_METHOD(vibrator::HalResult<milliseconds>, performComposedEffect,

                (const std::vector<CompositeEffect>& primitiveEffects,

                 const std::function<void()>& completionCallback),

                (override));
@@ -143,7 +143,7 @@ protected: 
                .WillRepeatedly(Return(durationResult));

        EXPECT_CALL(*mMockHal.get(), performComposedEffect(Eq(compositeEffects), _))

                .Times(Exactly(cardinality))

                .WillRepeatedly(Return(voidResult));

                .WillRepeatedly(Return(durationResult));



        if (cardinality > 1) {

            // One reconnection call after each failure.
@@ -208,7 +208,10 @@ TEST_F(VibratorHalControllerTest, TestApiCallsAreForwardedToHal) { 
    ASSERT_TRUE(performEffectResult.isOk());

    ASSERT_EQ(100ms, performEffectResult.value());



    ASSERT_TRUE(mController->performComposedEffect(compositeEffects, []() {}).isOk());

    auto performComposedEffectResult =

            mController->performComposedEffect(compositeEffects, []() {});

    ASSERT_TRUE(performComposedEffectResult.isOk());

    ASSERT_EQ(100ms, performComposedEffectResult.value());



    ASSERT_EQ(1, mConnectCounter);

}