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

Commit afcfe0fe authored by Ahmad Khalil's avatar Ahmad Khalil Committed by Android (Google) Code Review
Browse files

Merge "Implement Envelope Effect Limitations APIs" into main

parents f62eafa4 193e37b5

services/vibratorservice/VibratorHalWrapper.cpp

+46 −0
Original line number Diff line number Diff line
@@ -96,6 +96,17 @@ Info HalWrapper::getInfo() { 
    if (mInfoCache.mMaxAmplitudes.isFailed()) {

        mInfoCache.mMaxAmplitudes = getMaxAmplitudesInternal();

    }

    if (mInfoCache.mMaxEnvelopeEffectSize.isFailed()) {

        mInfoCache.mMaxEnvelopeEffectSize = getMaxEnvelopeEffectSizeInternal();

    }

    if (mInfoCache.mMinEnvelopeEffectControlPointDuration.isFailed()) {

        mInfoCache.mMinEnvelopeEffectControlPointDuration =

                getMinEnvelopeEffectControlPointDurationInternal();

    }

    if (mInfoCache.mMaxEnvelopeEffectControlPointDuration.isFailed()) {

        mInfoCache.mMaxEnvelopeEffectControlPointDuration =

                getMaxEnvelopeEffectControlPointDurationInternal();

    }

    return mInfoCache.get();

}
@@ -210,6 +221,23 @@ HalResult<std::vector<float>> HalWrapper::getMaxAmplitudesInternal() { 
    ALOGV("Skipped getMaxAmplitudes because it's not available in Vibrator HAL");

    return HalResult<std::vector<float>>::unsupported();

}

HalResult<int32_t> HalWrapper::getMaxEnvelopeEffectSizeInternal() {

    ALOGV("Skipped getMaxEnvelopeEffectSizeInternal because it's not available "

          "in Vibrator HAL");

    return HalResult<int32_t>::unsupported();

}



HalResult<milliseconds> HalWrapper::getMinEnvelopeEffectControlPointDurationInternal() {

    ALOGV("Skipped getMinEnvelopeEffectControlPointDurationInternal because it's not "

          "available in Vibrator HAL");

    return HalResult<milliseconds>::unsupported();

}



HalResult<milliseconds> HalWrapper::getMaxEnvelopeEffectControlPointDurationInternal() {

    ALOGV("Skipped getMaxEnvelopeEffectControlPointDurationInternal because it's not "

          "available in Vibrator HAL");

    return HalResult<milliseconds>::unsupported();

}



// -------------------------------------------------------------------------------------------------
@@ -441,6 +469,24 @@ HalResult<std::vector<float>> AidlHalWrapper::getMaxAmplitudesInternal() { 
    return HalResultFactory::fromStatus<std::vector<float>>(std::move(status), amplitudes);

}



HalResult<int32_t> AidlHalWrapper::getMaxEnvelopeEffectSizeInternal() {

    int32_t size = 0;

    auto status = getHal()->getPwleV2CompositionSizeMax(&size);

    return HalResultFactory::fromStatus<int32_t>(std::move(status), size);

}



HalResult<milliseconds> AidlHalWrapper::getMinEnvelopeEffectControlPointDurationInternal() {

    int32_t durationMs = 0;

    auto status = getHal()->getPwleV2PrimitiveDurationMinMillis(&durationMs);

    return HalResultFactory::fromStatus<milliseconds>(std::move(status), milliseconds(durationMs));

}



HalResult<milliseconds> AidlHalWrapper::getMaxEnvelopeEffectControlPointDurationInternal() {

    int32_t durationMs = 0;

    auto status = getHal()->getPwleV2PrimitiveDurationMaxMillis(&durationMs);

    return HalResultFactory::fromStatus<milliseconds>(std::move(status), milliseconds(durationMs));

}



std::shared_ptr<Aidl::IVibrator> AidlHalWrapper::getHal() {

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

    return mHandle;

services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h

+31 −2
Original line number Diff line number Diff line
@@ -258,6 +258,9 @@ public: 
    const HalResult<float> frequencyResolution;

    const HalResult<float> qFactor;

    const HalResult<std::vector<float>> maxAmplitudes;

    const HalResult<int32_t> maxEnvelopeEffectSize;

    const HalResult<std::chrono::milliseconds> minEnvelopeEffectControlPointDuration;

    const HalResult<std::chrono::milliseconds> maxEnvelopeEffectControlPointDuration;



    void logFailures() const {

        logFailure<Capabilities>(capabilities, "getCapabilities");
@@ -276,6 +279,11 @@ public: 
        logFailure<float>(frequencyResolution, "getFrequencyResolution");

        logFailure<float>(qFactor, "getQFactor");

        logFailure<std::vector<float>>(maxAmplitudes, "getMaxAmplitudes");

        logFailure<int32_t>(maxEnvelopeEffectSize, "getMaxEnvelopeEffectSize");

        logFailure<std::chrono::milliseconds>(minEnvelopeEffectControlPointDuration,

                                              "getMinEnvelopeEffectControlPointDuration");

        logFailure<std::chrono::milliseconds>(maxEnvelopeEffectControlPointDuration,

                                              "getMaxEnvelopeEffectControlPointDuration");

    }



    bool shouldRetry() const {
@@ -285,7 +293,10 @@ public: 
                pwlePrimitiveDurationMax.shouldRetry() || compositionSizeMax.shouldRetry() ||

                pwleSizeMax.shouldRetry() || minFrequency.shouldRetry() ||

                resonantFrequency.shouldRetry() || frequencyResolution.shouldRetry() ||

                qFactor.shouldRetry() || maxAmplitudes.shouldRetry();

                qFactor.shouldRetry() || maxAmplitudes.shouldRetry() ||

                maxEnvelopeEffectSize.shouldRetry() ||

                minEnvelopeEffectControlPointDuration.shouldRetry() ||

                maxEnvelopeEffectControlPointDuration.shouldRetry();

    }



private:
@@ -313,7 +324,10 @@ public: 
                mResonantFrequency,

                mFrequencyResolution,

                mQFactor,

                mMaxAmplitudes};

                mMaxAmplitudes,

                mMaxEnvelopeEffectSize,

                mMinEnvelopeEffectControlPointDuration,

                mMaxEnvelopeEffectControlPointDuration};

    }



private:
@@ -340,6 +354,11 @@ private: 
    HalResult<float> mQFactor = HalResult<float>::transactionFailed(MSG);

    HalResult<std::vector<float>> mMaxAmplitudes =

            HalResult<std::vector<float>>::transactionFailed(MSG);

    HalResult<int32_t> mMaxEnvelopeEffectSize = HalResult<int>::transactionFailed(MSG);

    HalResult<std::chrono::milliseconds> mMinEnvelopeEffectControlPointDuration =

            HalResult<std::chrono::milliseconds>::transactionFailed(MSG);

    HalResult<std::chrono::milliseconds> mMaxEnvelopeEffectControlPointDuration =

            HalResult<std::chrono::milliseconds>::transactionFailed(MSG);



    friend class HalWrapper;

};
@@ -420,6 +439,9 @@ protected: 
    virtual HalResult<float> getFrequencyResolutionInternal();

    virtual HalResult<float> getQFactorInternal();

    virtual HalResult<std::vector<float>> getMaxAmplitudesInternal();

    virtual HalResult<int32_t> getMaxEnvelopeEffectSizeInternal();

    virtual HalResult<std::chrono::milliseconds> getMinEnvelopeEffectControlPointDurationInternal();

    virtual HalResult<std::chrono::milliseconds> getMaxEnvelopeEffectControlPointDurationInternal();



private:

    std::mutex mInfoMutex;
@@ -495,6 +517,13 @@ protected: 
    HalResult<float> getFrequencyResolutionInternal() override final;

    HalResult<float> getQFactorInternal() override final;

    HalResult<std::vector<float>> getMaxAmplitudesInternal() override final;

    HalResult<int32_t> getMaxEnvelopeEffectSizeInternal() override final;



    HalResult<std::chrono::milliseconds> getMinEnvelopeEffectControlPointDurationInternal()

            override final;



    HalResult<std::chrono::milliseconds> getMaxEnvelopeEffectControlPointDurationInternal()

            override final;



private:

    const reconnect_fn mReconnectFn;

services/vibratorservice/test/VibratorHalWrapperAidlTest.cpp

+46 −0
Original line number Diff line number Diff line
@@ -235,6 +235,9 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    constexpr int32_t PWLE_SIZE_MAX = 20;

    constexpr int32_t PRIMITIVE_DELAY_MAX = 100;

    constexpr int32_t PWLE_DURATION_MAX = 200;

    constexpr int32_t PWLE_V2_COMPOSITION_SIZE_MAX = 16;

    constexpr int32_t PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS = 20;

    constexpr int32_t PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS = 1000;

    std::vector<Effect> supportedEffects = {Effect::CLICK, Effect::TICK};

    std::vector<CompositePrimitive> supportedPrimitives = {CompositePrimitive::CLICK};

    std::vector<Braking> supportedBraking = {Braking::CLAB};
@@ -305,6 +308,21 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
            .Times(Exactly(2))

            .WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))

            .WillOnce(DoAll(SetArgPointee<0>(amplitudes), Return(ndk::ScopedAStatus::ok())));

    EXPECT_CALL(*mMockHal.get(), getPwleV2CompositionSizeMax(_))

            .Times(Exactly(2))

            .WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_COMPOSITION_SIZE_MAX),

                            Return(ndk::ScopedAStatus::ok())));

    EXPECT_CALL(*mMockHal.get(), getPwleV2PrimitiveDurationMinMillis(_))

            .Times(Exactly(2))

            .WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS),

                            Return(ndk::ScopedAStatus::ok())));

    EXPECT_CALL(*mMockHal.get(), getPwleV2PrimitiveDurationMaxMillis(_))

            .Times(Exactly(2))

            .WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_SECURITY)))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS),

                            Return(ndk::ScopedAStatus::ok())));



    vibrator::Info failed = mWrapper->getInfo();

    ASSERT_TRUE(failed.capabilities.isFailed());
@@ -321,6 +339,9 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_TRUE(failed.frequencyResolution.isFailed());

    ASSERT_TRUE(failed.qFactor.isFailed());

    ASSERT_TRUE(failed.maxAmplitudes.isFailed());

    ASSERT_TRUE(failed.maxEnvelopeEffectSize.isFailed());

    ASSERT_TRUE(failed.minEnvelopeEffectControlPointDuration.isFailed());

    ASSERT_TRUE(failed.maxEnvelopeEffectControlPointDuration.isFailed());



    vibrator::Info successful = mWrapper->getInfo();

    ASSERT_EQ(vibrator::Capabilities::ON_CALLBACK, successful.capabilities.value());
@@ -338,6 +359,11 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_EQ(F_RESOLUTION, successful.frequencyResolution.value());

    ASSERT_EQ(Q_FACTOR, successful.qFactor.value());

    ASSERT_EQ(amplitudes, successful.maxAmplitudes.value());

    ASSERT_EQ(PWLE_V2_COMPOSITION_SIZE_MAX, successful.maxEnvelopeEffectSize.value());

    ASSERT_EQ(std::chrono::milliseconds(PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS),

              successful.minEnvelopeEffectControlPointDuration.value());

    ASSERT_EQ(std::chrono::milliseconds(PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS),

              successful.maxEnvelopeEffectControlPointDuration.value());

}



TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) {
@@ -347,6 +373,9 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) { 
    constexpr int32_t PWLE_SIZE_MAX = 20;

    constexpr int32_t PRIMITIVE_DELAY_MAX = 100;

    constexpr int32_t PWLE_DURATION_MAX = 200;

    constexpr int32_t PWLE_V2_COMPOSITION_SIZE_MAX = 16;

    constexpr int32_t PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS = 20;

    constexpr int32_t PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS = 1000;

    std::vector<Effect> supportedEffects = {Effect::CLICK, Effect::TICK};



    EXPECT_CALL(*mMockHal.get(), getCapabilities(_))
@@ -391,6 +420,18 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) { 
    EXPECT_CALL(*mMockHal.get(), getSupportedBraking(_))

            .Times(Exactly(1))

            .WillOnce(Return(ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION)));

    EXPECT_CALL(*mMockHal.get(), getPwleV2CompositionSizeMax(_))

            .Times(Exactly(1))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_COMPOSITION_SIZE_MAX),

                            Return(ndk::ScopedAStatus::ok())));

    EXPECT_CALL(*mMockHal.get(), getPwleV2PrimitiveDurationMinMillis(_))

            .Times(Exactly(1))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS),

                            Return(ndk::ScopedAStatus::ok())));

    EXPECT_CALL(*mMockHal.get(), getPwleV2PrimitiveDurationMaxMillis(_))

            .Times(Exactly(1))

            .WillOnce(DoAll(SetArgPointee<0>(PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS),

                            Return(ndk::ScopedAStatus::ok())));



    std::vector<std::thread> threads;

    for (int i = 0; i < 10; i++) {
@@ -414,6 +455,11 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) { 
    ASSERT_TRUE(info.frequencyResolution.isUnsupported());

    ASSERT_TRUE(info.qFactor.isUnsupported());

    ASSERT_TRUE(info.maxAmplitudes.isUnsupported());

    ASSERT_EQ(PWLE_V2_COMPOSITION_SIZE_MAX, info.maxEnvelopeEffectSize.value());

    ASSERT_EQ(std::chrono::milliseconds(PWLE_V2_MAX_ALLOWED_PRIMITIVE_MIN_DURATION_MS),

              info.minEnvelopeEffectControlPointDuration.value());

    ASSERT_EQ(std::chrono::milliseconds(PWLE_V2_MIN_REQUIRED_PRIMITIVE_MAX_DURATION_MS),

              info.maxEnvelopeEffectControlPointDuration.value());

}



TEST_F(VibratorHalWrapperAidlTest, TestPerformEffectWithCallbackSupport) {

services/vibratorservice/test/VibratorHalWrapperHidlV1_0Test.cpp

+6 −0
Original line number Diff line number Diff line
@@ -220,6 +220,9 @@ TEST_F(VibratorHalWrapperHidlV1_0Test, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_TRUE(info.frequencyResolution.isUnsupported());

    ASSERT_TRUE(info.qFactor.isUnsupported());

    ASSERT_TRUE(info.maxAmplitudes.isUnsupported());

    ASSERT_TRUE(info.maxEnvelopeEffectSize.isUnsupported());

    ASSERT_TRUE(info.minEnvelopeEffectControlPointDuration.isUnsupported());

    ASSERT_TRUE(info.maxEnvelopeEffectControlPointDuration.isUnsupported());

}



TEST_F(VibratorHalWrapperHidlV1_0Test, TestGetInfoWithoutAmplitudeControl) {
@@ -253,6 +256,9 @@ TEST_F(VibratorHalWrapperHidlV1_0Test, TestGetInfoCachesResult) { 
    ASSERT_TRUE(info.frequencyResolution.isUnsupported());

    ASSERT_TRUE(info.qFactor.isUnsupported());

    ASSERT_TRUE(info.maxAmplitudes.isUnsupported());

    ASSERT_TRUE(info.maxEnvelopeEffectSize.isUnsupported());

    ASSERT_TRUE(info.minEnvelopeEffectControlPointDuration.isUnsupported());

    ASSERT_TRUE(info.maxEnvelopeEffectControlPointDuration.isUnsupported());

}



TEST_F(VibratorHalWrapperHidlV1_0Test, TestPerformEffect) {