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

Commit 91243f0e 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: ef1db93c 

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

Change-Id: I95384c5c88c3806e08b419766fb91ebfde7fe634
parents ebec6cae ef1db93c

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