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

Commit 8abc1899 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Expose HAL limits for composed and PWLE vibrations" into sc-dev am:... 

Merge "Expose HAL limits for composed and PWLE vibrations" into sc-dev am: ef1db93c am: ed2a5dc2

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/14822600

Change-Id: I7ea69ed1c7453a46fa72880091c749296a097e12
parents 46ef612b ed2a5dc2

services/vibratorservice/VibratorHalWrapper.cpp

+56 −0
Original line number Diff line number Diff line
@@ -135,6 +135,18 @@ Info HalWrapper::getInfo() { 
    if (mInfoCache.mSupportedBraking.isFailed()) {

        mInfoCache.mSupportedBraking = getSupportedBrakingInternal();

    }

    if (mInfoCache.mPrimitiveDelayMax.isFailed()) {

        mInfoCache.mPrimitiveDelayMax = getPrimitiveDelayMaxInternal();

    }

    if (mInfoCache.mPwlePrimitiveDurationMax.isFailed()) {

        mInfoCache.mPwlePrimitiveDurationMax = getPrimitiveDurationMaxInternal();

    }

    if (mInfoCache.mCompositionSizeMax.isFailed()) {

        mInfoCache.mCompositionSizeMax = getCompositionSizeMaxInternal();

    }

    if (mInfoCache.mPwleSizeMax.isFailed()) {

        mInfoCache.mPwleSizeMax = getPwleSizeMaxInternal();

    }

    if (mInfoCache.mMinFrequency.isFailed()) {

        mInfoCache.mMinFrequency = getMinFrequencyInternal();

    }
@@ -209,6 +221,26 @@ HalResult<std::vector<milliseconds>> HalWrapper::getPrimitiveDurationsInternal( 
    return HalResult<std::vector<milliseconds>>::unsupported();

}



HalResult<milliseconds> HalWrapper::getPrimitiveDelayMaxInternal() {

    ALOGV("Skipped getPrimitiveDelayMaxInternal because it's not available in Vibrator HAL");

    return HalResult<milliseconds>::unsupported();

}



HalResult<milliseconds> HalWrapper::getPrimitiveDurationMaxInternal() {

    ALOGV("Skipped getPrimitiveDurationMaxInternal because it's not available in Vibrator HAL");

    return HalResult<milliseconds>::unsupported();

}



HalResult<int32_t> HalWrapper::getCompositionSizeMaxInternal() {

    ALOGV("Skipped getCompositionSizeMaxInternal because it's not available in Vibrator HAL");

    return HalResult<int32_t>::unsupported();

}



HalResult<int32_t> HalWrapper::getPwleSizeMaxInternal() {

    ALOGV("Skipped getPwleSizeMaxInternal because it's not available in Vibrator HAL");

    return HalResult<int32_t>::unsupported();

}



HalResult<float> HalWrapper::getMinFrequencyInternal() {

    ALOGV("Skipped getMinFrequency because it's not available in Vibrator HAL");

    return HalResult<float>::unsupported();
@@ -383,6 +415,30 @@ HalResult<std::vector<milliseconds>> AidlHalWrapper::getPrimitiveDurationsIntern 
    return HalResult<std::vector<milliseconds>>::ok(durations);

}



HalResult<milliseconds> AidlHalWrapper::getPrimitiveDelayMaxInternal() {

    int32_t delay = 0;

    auto result = getHal()->getCompositionDelayMax(&delay);

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

}



HalResult<milliseconds> AidlHalWrapper::getPrimitiveDurationMaxInternal() {

    int32_t delay = 0;

    auto result = getHal()->getPwlePrimitiveDurationMax(&delay);

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

}



HalResult<int32_t> AidlHalWrapper::getCompositionSizeMaxInternal() {

    int32_t size = 0;

    auto result = getHal()->getCompositionSizeMax(&size);

    return HalResult<int32_t>::fromStatus(result, size);

}



HalResult<int32_t> AidlHalWrapper::getPwleSizeMaxInternal() {

    int32_t size = 0;

    auto result = getHal()->getPwleCompositionSizeMax(&size);

    return HalResult<int32_t>::fromStatus(result, size);

}



HalResult<float> AidlHalWrapper::getMinFrequencyInternal() {

    float minFrequency = 0;

    auto result = getHal()->getFrequencyMinimum(&minFrequency);

services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h

+35 −3
Original line number Diff line number Diff line
@@ -182,6 +182,10 @@ public: 
    const HalResult<std::vector<hardware::vibrator::Braking>> supportedBraking;

    const HalResult<std::vector<hardware::vibrator::CompositePrimitive>> supportedPrimitives;

    const HalResult<std::vector<std::chrono::milliseconds>> primitiveDurations;

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

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

    const HalResult<int32_t> compositionSizeMax;

    const HalResult<int32_t> pwleSizeMax;

    const HalResult<float> minFrequency;

    const HalResult<float> resonantFrequency;

    const HalResult<float> frequencyResolution;
@@ -194,6 +198,10 @@ public: 
                supportedBraking.checkAndLogFailure("getSupportedBraking") ||

                supportedPrimitives.checkAndLogFailure("getSupportedPrimitives") ||

                primitiveDurations.checkAndLogFailure("getPrimitiveDuration") ||

                primitiveDelayMax.checkAndLogFailure("getPrimitiveDelayMax") ||

                pwlePrimitiveDurationMax.checkAndLogFailure("getPwlePrimitiveDurationMax") ||

                compositionSizeMax.checkAndLogFailure("getCompositionSizeMax") ||

                pwleSizeMax.checkAndLogFailure("getPwleSizeMax") ||

                minFrequency.checkAndLogFailure("getMinFrequency") ||

                resonantFrequency.checkAndLogFailure("getResonantFrequency") ||

                frequencyResolution.checkAndLogFailure("getFrequencyResolution") ||
@@ -205,9 +213,19 @@ public: 
class InfoCache {

public:

    Info get() {

        return {mCapabilities,        mSupportedEffects,    mSupportedBraking,

                mSupportedPrimitives, mPrimitiveDurations,  mMinFrequency,

                mResonantFrequency,   mFrequencyResolution, mQFactor,

        return {mCapabilities,

                mSupportedEffects,

                mSupportedBraking,

                mSupportedPrimitives,

                mPrimitiveDurations,

                mPrimitiveDelayMax,

                mPwlePrimitiveDurationMax,

                mCompositionSizeMax,

                mPwleSizeMax,

                mMinFrequency,

                mResonantFrequency,

                mFrequencyResolution,

                mQFactor,

                mMaxAmplitudes};

    }
@@ -222,6 +240,12 @@ private: 
            HalResult<std::vector<hardware::vibrator::CompositePrimitive>>::failed(MSG);

    HalResult<std::vector<std::chrono::milliseconds>> mPrimitiveDurations =

            HalResult<std::vector<std::chrono::milliseconds>>::failed(MSG);

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

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

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

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

    HalResult<int32_t> mCompositionSizeMax = HalResult<int>::failed(MSG);

    HalResult<int32_t> mPwleSizeMax = HalResult<int>::failed(MSG);

    HalResult<float> mMinFrequency = HalResult<float>::failed(MSG);

    HalResult<float> mResonantFrequency = HalResult<float>::failed(MSG);

    HalResult<float> mFrequencyResolution = HalResult<float>::failed(MSG);
@@ -285,6 +309,10 @@ protected: 
    getSupportedPrimitivesInternal();

    virtual HalResult<std::vector<std::chrono::milliseconds>> getPrimitiveDurationsInternal(

            const std::vector<hardware::vibrator::CompositePrimitive>& supportedPrimitives);

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

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

    virtual HalResult<int32_t> getCompositionSizeMaxInternal();

    virtual HalResult<int32_t> getPwleSizeMaxInternal();

    virtual HalResult<float> getMinFrequencyInternal();

    virtual HalResult<float> getResonantFrequencyInternal();

    virtual HalResult<float> getFrequencyResolutionInternal();
@@ -347,6 +375,10 @@ protected: 
    HalResult<std::vector<std::chrono::milliseconds>> getPrimitiveDurationsInternal(

            const std::vector<hardware::vibrator::CompositePrimitive>& supportedPrimitives)

            override final;

    HalResult<std::chrono::milliseconds> getPrimitiveDelayMaxInternal() override final;

    HalResult<std::chrono::milliseconds> getPrimitiveDurationMaxInternal() override final;

    HalResult<int32_t> getCompositionSizeMaxInternal() override final;

    HalResult<int32_t> getPwleSizeMaxInternal() override final;

    HalResult<float> getMinFrequencyInternal() override final;

    HalResult<float> getResonantFrequencyInternal() override final;

    HalResult<float> getFrequencyResolutionInternal() override final;

services/vibratorservice/test/VibratorHalWrapperAidlTest.cpp

+49 −0
Original line number Diff line number Diff line
@@ -301,6 +301,10 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    constexpr float F0 = 123.f;

    constexpr float F_RESOLUTION = 0.5f;

    constexpr float Q_FACTOR = 123.f;

    constexpr int32_t COMPOSITION_SIZE_MAX = 10;

    constexpr int32_t PWLE_SIZE_MAX = 20;

    constexpr int32_t PRIMITIVE_DELAY_MAX = 100;

    constexpr int32_t PWLE_DURATION_MAX = 200;

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

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

    std::vector<Braking> supportedBraking = {Braking::CLAB};
@@ -331,6 +335,22 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    EXPECT_CALL(*mMockHal.get(), getPrimitiveDuration(Eq(CompositePrimitive::CLICK), _))

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<1>(10), Return(Status())));

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

            .Times(Exactly(2))

            .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_SECURITY)))

            .WillRepeatedly(DoAll(SetArgPointee<0>(COMPOSITION_SIZE_MAX), Return(Status())));

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

            .Times(Exactly(2))

            .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_SECURITY)))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PRIMITIVE_DELAY_MAX), Return(Status())));

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

            .Times(Exactly(2))

            .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_SECURITY)))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PWLE_DURATION_MAX), Return(Status())));

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

            .Times(Exactly(2))

            .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_SECURITY)))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PWLE_SIZE_MAX), Return(Status())));

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

            .Times(Exactly(2))

            .WillOnce(Return(Status::fromExceptionCode(Status::Exception::EX_SECURITY)))
@@ -358,6 +378,10 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_TRUE(failed.supportedBraking.isFailed());

    ASSERT_TRUE(failed.supportedPrimitives.isFailed());

    ASSERT_TRUE(failed.primitiveDurations.isFailed());

    ASSERT_TRUE(failed.primitiveDelayMax.isFailed());

    ASSERT_TRUE(failed.pwlePrimitiveDurationMax.isFailed());

    ASSERT_TRUE(failed.compositionSizeMax.isFailed());

    ASSERT_TRUE(failed.pwleSizeMax.isFailed());

    ASSERT_TRUE(failed.minFrequency.isFailed());

    ASSERT_TRUE(failed.resonantFrequency.isFailed());

    ASSERT_TRUE(failed.frequencyResolution.isFailed());
@@ -370,6 +394,11 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_EQ(supportedBraking, successful.supportedBraking.value());

    ASSERT_EQ(supportedPrimitives, successful.supportedPrimitives.value());

    ASSERT_EQ(primitiveDurations, successful.primitiveDurations.value());

    ASSERT_EQ(std::chrono::milliseconds(PRIMITIVE_DELAY_MAX), successful.primitiveDelayMax.value());

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

              successful.pwlePrimitiveDurationMax.value());

    ASSERT_EQ(COMPOSITION_SIZE_MAX, successful.compositionSizeMax.value());

    ASSERT_EQ(PWLE_SIZE_MAX, successful.pwleSizeMax.value());

    ASSERT_EQ(F_MIN, successful.minFrequency.value());

    ASSERT_EQ(F0, successful.resonantFrequency.value());

    ASSERT_EQ(F_RESOLUTION, successful.frequencyResolution.value());
@@ -380,6 +409,10 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoDoesNotCacheFailedResult) { 
TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) {

    constexpr float F_MIN = 100.f;

    constexpr float F0 = 123.f;

    constexpr int32_t COMPOSITION_SIZE_MAX = 10;

    constexpr int32_t PWLE_SIZE_MAX = 20;

    constexpr int32_t PRIMITIVE_DELAY_MAX = 100;

    constexpr int32_t PWLE_DURATION_MAX = 200;

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



    EXPECT_CALL(*mMockHal.get(), getCapabilities(_))
@@ -395,6 +428,18 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) { 
    EXPECT_CALL(*mMockHal.get(), getSupportedPrimitives(_))

            .Times(Exactly(1))

            .WillRepeatedly(Return(Status::fromStatusT(UNKNOWN_TRANSACTION)));

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

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<0>(COMPOSITION_SIZE_MAX), Return(Status())));

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

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PRIMITIVE_DELAY_MAX), Return(Status())));

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

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PWLE_DURATION_MAX), Return(Status())));

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

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<0>(PWLE_SIZE_MAX), Return(Status())));

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

            .Times(Exactly(1))

            .WillRepeatedly(DoAll(SetArgPointee<0>(F_MIN), Return(Status())));
@@ -426,6 +471,10 @@ TEST_F(VibratorHalWrapperAidlTest, TestGetInfoCachesResult) { 
    ASSERT_TRUE(info.supportedBraking.isUnsupported());

    ASSERT_TRUE(info.supportedPrimitives.isUnsupported());

    ASSERT_TRUE(info.primitiveDurations.isUnsupported());

    ASSERT_EQ(std::chrono::milliseconds(PRIMITIVE_DELAY_MAX), info.primitiveDelayMax.value());

    ASSERT_EQ(std::chrono::milliseconds(PWLE_DURATION_MAX), info.pwlePrimitiveDurationMax.value());

    ASSERT_EQ(COMPOSITION_SIZE_MAX, info.compositionSizeMax.value());

    ASSERT_EQ(PWLE_SIZE_MAX, info.pwleSizeMax.value());

    ASSERT_EQ(F_MIN, info.minFrequency.value());

    ASSERT_EQ(F0, info.resonantFrequency.value());

    ASSERT_TRUE(info.frequencyResolution.isUnsupported());

services/vibratorservice/test/VibratorHalWrapperHidlV1_0Test.cpp

+4 −0
Original line number Diff line number Diff line
@@ -206,6 +206,10 @@ TEST_F(VibratorHalWrapperHidlV1_0Test, TestGetInfoDoesNotCacheFailedResult) { 
    ASSERT_TRUE(info.supportedBraking.isUnsupported());

    ASSERT_TRUE(info.supportedPrimitives.isUnsupported());

    ASSERT_TRUE(info.primitiveDurations.isUnsupported());

    ASSERT_TRUE(info.primitiveDelayMax.isUnsupported());

    ASSERT_TRUE(info.pwlePrimitiveDurationMax.isUnsupported());

    ASSERT_TRUE(info.compositionSizeMax.isUnsupported());

    ASSERT_TRUE(info.pwleSizeMax.isUnsupported());

    ASSERT_TRUE(info.minFrequency.isUnsupported());

    ASSERT_TRUE(info.resonantFrequency.isUnsupported());

    ASSERT_TRUE(info.frequencyResolution.isUnsupported());