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

Commit fb6e7a8f authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Haptic Generator : Modify HapticScale param to be a list"

parents 0f884979 c7d237de

audio/aidl/aidl_api/android.hardware.audio.effect/current/android/hardware/audio/effect/HapticGenerator.aidl

+1 −1
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ package android.hardware.audio.effect; 
@VintfStability

union HapticGenerator {

  android.hardware.audio.effect.VendorExtension vendorExtension;

  android.hardware.audio.effect.HapticGenerator.HapticScale hapticScale;

  android.hardware.audio.effect.HapticGenerator.HapticScale[] hapticScales;

  android.hardware.audio.effect.HapticGenerator.VibratorInformation vibratorInfo;

  @VintfStability

  union Id {

audio/aidl/android/hardware/audio/effect/HapticGenerator.aidl

+1 −1
Original line number Diff line number Diff line
@@ -90,6 +90,6 @@ union HapticGenerator { 
        float maxAmplitude;

    }



    HapticScale hapticScale;

    HapticScale[] hapticScales;

    VibratorInformation vibratorInfo;

}

audio/aidl/default/hapticGenerator/HapticGeneratorSw.cpp

+20 −4
Original line number Diff line number Diff line
@@ -90,8 +90,8 @@ ndk::ScopedAStatus HapticGeneratorSw::setParameterSpecific(const Parameter::Spec 
    auto tag = hgParam.getTag();



    switch (tag) {

        case HapticGenerator::hapticScale: {

            RETURN_IF(mContext->setHgHapticScale(hgParam.get<HapticGenerator::hapticScale>()) !=

        case HapticGenerator::hapticScales: {

            RETURN_IF(mContext->setHgHapticScales(hgParam.get<HapticGenerator::hapticScales>()) !=

                              RetCode::SUCCESS,

                      EX_ILLEGAL_ARGUMENT, "HapticScaleNotSupported");

            return ndk::ScopedAStatus::ok();
@@ -133,8 +133,8 @@ ndk::ScopedAStatus HapticGeneratorSw::getParameterHapticGenerator(const HapticGe 


    HapticGenerator hgParam;

    switch (tag) {

        case HapticGenerator::hapticScale: {

            hgParam.set<HapticGenerator::hapticScale>(mContext->getHgHapticScale());

        case HapticGenerator::hapticScales: {

            hgParam.set<HapticGenerator::hapticScales>(mContext->getHgHapticScales());

            break;

        }

        case HapticGenerator::vibratorInfo: {
@@ -183,4 +183,20 @@ IEffect::Status HapticGeneratorSw::effectProcessImpl(float* in, float* out, int 
    return {STATUS_OK, samples, samples};

}



RetCode HapticGeneratorSwContext::setHgHapticScales(

        const std::vector<HapticGenerator::HapticScale>& hapticScales) {

    // Assume any audio track ID is valid

    for (auto& it : hapticScales) {

        mHapticScales[it.id] = it;

    }

    return RetCode::SUCCESS;

}



std::vector<HapticGenerator::HapticScale> HapticGeneratorSwContext::getHgHapticScales() const {

    std::vector<HapticGenerator::HapticScale> result;

    std::transform(mHapticScales.begin(), mHapticScales.end(), std::back_inserter(result),

                   [](auto& scaleIt) { return scaleIt.second; });

    return result;

}



}  // namespace aidl::android::hardware::audio::effect

audio/aidl/default/hapticGenerator/HapticGeneratorSw.h

+3 −7
Original line number Diff line number Diff line
@@ -33,12 +33,8 @@ class HapticGeneratorSwContext final : public EffectContext { 
        LOG(DEBUG) << __func__;

    }



    RetCode setHgHapticScale(const HapticGenerator::HapticScale& hapticScale) {

        // All int values are valid for ID

        mHapticScale = hapticScale;

        return RetCode::SUCCESS;

    }

    HapticGenerator::HapticScale getHgHapticScale() const { return mHapticScale; }

    RetCode setHgHapticScales(const std::vector<HapticGenerator::HapticScale>& hapticScales);

    std::vector<HapticGenerator::HapticScale> getHgHapticScales() const;



    RetCode setHgVibratorInformation(const HapticGenerator::VibratorInformation& vibratorInfo) {

        // All float values are valid for resonantFrequencyHz, qFactor, maxAmplitude
@@ -54,7 +50,7 @@ class HapticGeneratorSwContext final : public EffectContext { 
    static constexpr float DEFAULT_RESONANT_FREQUENCY = 150.0f;

    static constexpr float DEFAULT_Q_FACTOR = 1.0f;

    static constexpr float DEFAULT_MAX_AMPLITUDE = 0.0f;

    HapticGenerator::HapticScale mHapticScale = {0, HapticGenerator::VibratorScale::MUTE};

    std::map<int /* trackID */, HapticGenerator::HapticScale> mHapticScales;

    HapticGenerator::VibratorInformation mVibratorInformation = {

            DEFAULT_RESONANT_FREQUENCY, DEFAULT_Q_FACTOR, DEFAULT_MAX_AMPLITUDE};

};

audio/aidl/vts/VtsHalHapticGeneratorTargetTest.cpp

+216 −23
Original line number Diff line number Diff line
@@ -19,7 +19,9 @@ 
#include <Utils.h>

#include <aidl/Vintf.h>

#include <android/binder_enums.h>

#include <unordered_set>

#include <map>

#include <utility>

#include <vector>



#include "EffectHelper.h"
@@ -87,12 +89,11 @@ class HapticGeneratorParamTest : public ::testing::TestWithParam<HapticGenerator 
        ASSERT_NE(nullptr, mFactory);

        ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));



        Parameter::Specific specific = getDefaultParamSpecific();

        Parameter::Common common = EffectHelper::createParamCommon(

                0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,

                kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);

        IEffect::OpenEffectReturn ret;

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, specific, &ret, EX_NONE));

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &ret, EX_NONE));

        ASSERT_NE(nullptr, mEffect);

    }
@@ -101,15 +102,6 @@ class HapticGeneratorParamTest : public ::testing::TestWithParam<HapticGenerator 
        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

    }



    Parameter::Specific getDefaultParamSpecific() {

        HapticGenerator::HapticScale hapticScale = {.id = 0,

                                                    .scale = HapticGenerator::VibratorScale::MUTE};

        HapticGenerator hg = HapticGenerator::make<HapticGenerator::hapticScale>(hapticScale);

        Parameter::Specific specific =

                Parameter::Specific::make<Parameter::Specific::hapticGenerator>(hg);

        return specific;

    }



    static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;
@@ -122,13 +114,13 @@ class HapticGeneratorParamTest : public ::testing::TestWithParam<HapticGenerator 


    void SetAndGetHapticGeneratorParameters() {

        for (auto& it : mTags) {

            auto& tag = it.first;

            auto& hg = it.second;

            auto& tag = std::get<ParamTestEnum::PARAM_TEST_TAG>(it);

            auto& setHg = std::get<ParamTestEnum::PARAM_TEST_TARGET>(it);



            // set parameter

            Parameter expectParam;

            Parameter::Specific specific;

            specific.set<Parameter::Specific::hapticGenerator>(hg);

            specific.set<Parameter::Specific::hapticGenerator>(setHg);

            expectParam.set<Parameter::specific>(specific);

            EXPECT_STATUS(EX_NONE, mEffect->setParameter(expectParam)) << expectParam.toString();
@@ -139,15 +131,16 @@ class HapticGeneratorParamTest : public ::testing::TestWithParam<HapticGenerator 
            hgId.set<HapticGenerator::Id::commonTag>(tag);

            id.set<Parameter::Id::hapticGeneratorTag>(hgId);

            EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &getParam));

            EXPECT_EQ(expectParam, getParam);

            EXPECT_EQ(expectParam, getParam) << expectParam.toString() << "\n"

                                             << getParam.toString();

        }

    }



    void addHapticScaleParam(int id, HapticGenerator::VibratorScale scale) {

        HapticGenerator hg;

        HapticGenerator::HapticScale hapticScale = {.id = id, .scale = scale};

        hg.set<HapticGenerator::hapticScale>(hapticScale);

        mTags.push_back({HapticGenerator::hapticScale, hg});

        HapticGenerator setHg;

        std::vector<HapticGenerator::HapticScale> hapticScales = {{.id = id, .scale = scale}};

        setHg.set<HapticGenerator::hapticScales>(hapticScales);

        mTags.push_back({HapticGenerator::hapticScales, setHg});

    }



    void addVibratorInformationParam(float resonantFrequencyHz, float qFactor, float maxAmplitude) {
@@ -161,7 +154,8 @@ class HapticGeneratorParamTest : public ::testing::TestWithParam<HapticGenerator 
    }



  private:

    std::vector<std::pair<HapticGenerator::Tag, HapticGenerator>> mTags;

    enum ParamTestEnum { PARAM_TEST_TAG, PARAM_TEST_TARGET };

    std::vector<std::tuple<HapticGenerator::Tag, HapticGenerator>> mTags;



    void CleanUp() { mTags.clear(); }

};
@@ -171,6 +165,12 @@ TEST_P(HapticGeneratorParamTest, SetAndGetHapticScale) { 
    SetAndGetHapticGeneratorParameters();

}



TEST_P(HapticGeneratorParamTest, SetAndGetMultipleHapticScales) {

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam(mParamHapticScaleId, mParamVibratorScale));

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam(mParamHapticScaleId, mParamVibratorScale));

    SetAndGetHapticGeneratorParameters();

}



TEST_P(HapticGeneratorParamTest, SetAndGetVibratorInformation) {

    EXPECT_NO_FATAL_FAILURE(addVibratorInformationParam(mParamResonantFrequency, mParamQFactor,

                                                        mParamMaxAmplitude));
@@ -212,7 +212,7 @@ INSTANTIATE_TEST_SUITE_P( 
        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                                   IFactory::descriptor, kHapticGeneratorTypeUUID)),

                           testing::Values(MIN_ID - 1),

                           testing::Values(HapticGenerator::VibratorScale::MUTE),

                           testing::Values(HapticGenerator::VibratorScale::NONE),

                           testing::Values(MIN_FLOAT), testing::Values(MIN_FLOAT),

                           testing::Values(MIN_FLOAT)),

        [](const testing::TestParamInfo<HapticGeneratorParamTest::ParamType>& info) {
@@ -236,9 +236,202 @@ INSTANTIATE_TEST_SUITE_P( 
                    name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');

            return name;

        });



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HapticGeneratorParamTest);



// Test HapticScale[] hapticScales parameter

using HapticGeneratorScalesTestParam = std::tuple<std::pair<std::shared_ptr<IFactory>, Descriptor>>;

class HapticGeneratorScalesTest : public ::testing::TestWithParam<HapticGeneratorScalesTestParam>,

                                  public EffectHelper {

  public:

    HapticGeneratorScalesTest() {

        std::tie(mFactory, mDescriptor) = std::get<PARAM_INSTANCE_NAME>(GetParam());

    }



    void SetUp() override {

        ASSERT_NE(nullptr, mFactory);

        ASSERT_NO_FATAL_FAILURE(create(mFactory, mEffect, mDescriptor));



        Parameter::Common common = EffectHelper::createParamCommon(

                0 /* session */, 1 /* ioHandle */, 44100 /* iSampleRate */, 44100 /* oSampleRate */,

                kInputFrameCount /* iFrameCount */, kOutputFrameCount /* oFrameCount */);

        IEffect::OpenEffectReturn ret;

        ASSERT_NO_FATAL_FAILURE(open(mEffect, common, std::nullopt, &ret, EX_NONE));

        ASSERT_NE(nullptr, mEffect);

    }



    void TearDown() override {

        ASSERT_NO_FATAL_FAILURE(close(mEffect));

        ASSERT_NO_FATAL_FAILURE(destroy(mFactory, mEffect));

        CleanUp();

    }



    static const long kInputFrameCount = 0x100, kOutputFrameCount = 0x100;

    std::shared_ptr<IFactory> mFactory;

    std::shared_ptr<IEffect> mEffect;

    Descriptor mDescriptor;



    void addHapticScaleParam(std::vector<HapticGenerator::HapticScale> scales) {

        mHapticScales.push_back(HapticGenerator::make<HapticGenerator::hapticScales>(scales));

        for (const auto& scale : scales) {

            expectMap.insert_or_assign(scale.id, scale.scale);

        }

    }



    void SetHapticScaleParameters() {

        // std::unordered_set<HapticGenerator::HapticScale> target;

        for (auto& it : mHapticScales) {

            Parameter::Specific specific =

                    Parameter::Specific::make<Parameter::Specific::hapticGenerator>(it);

            Parameter param = Parameter::make<Parameter::specific>(specific);

            EXPECT_STATUS(EX_NONE, mEffect->setParameter(param)) << param.toString();

        }

    }



    void checkHapticScaleParameter() {

        // get parameter

        Parameter targetParam;

        HapticGenerator::Id hgId = HapticGenerator::Id::make<HapticGenerator::Id::commonTag>(

                HapticGenerator::hapticScales);

        Parameter::Id id = Parameter::Id::make<Parameter::Id::hapticGeneratorTag>(hgId);

        EXPECT_STATUS(EX_NONE, mEffect->getParameter(id, &targetParam));

        ASSERT_EQ(Parameter::specific, targetParam.getTag());

        Parameter::Specific specific = targetParam.get<Parameter::specific>();

        ASSERT_EQ(Parameter::Specific::hapticGenerator, specific.getTag());

        HapticGenerator hg = specific.get<Parameter::Specific::hapticGenerator>();

        ASSERT_EQ(HapticGenerator::hapticScales, hg.getTag());

        std::vector<HapticGenerator::HapticScale> scales = hg.get<HapticGenerator::hapticScales>();

        ASSERT_EQ(scales.size(), expectMap.size());

        for (const auto& scale : scales) {

            auto itor = expectMap.find(scale.id);

            ASSERT_NE(expectMap.end(), itor);

            ASSERT_EQ(scale.scale, itor->second);

            expectMap.erase(scale.id);

        }

        ASSERT_EQ(0ul, expectMap.size());

    }



    const static HapticGenerator::HapticScale kHapticScaleWithMinId;

    const static HapticGenerator::HapticScale kHapticScaleWithMinIdNew;

    const static HapticGenerator::HapticScale kHapticScale;

    const static HapticGenerator::HapticScale kHapticScaleNew;

    const static HapticGenerator::HapticScale kHapticScaleWithMaxId;

    const static HapticGenerator::HapticScale kHapticScaleWithMaxIdNew;



    std::vector<HapticGenerator> mHapticScales;



    void CleanUp() {

        mHapticScales.clear();

        expectMap.clear();

    }



  private:

    std::map<int /* trackID */, HapticGenerator::VibratorScale> expectMap;

};



const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScaleWithMinId = {

        .id = MIN_ID, .scale = HapticGenerator::VibratorScale::MUTE};

const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScaleWithMinIdNew = {

        .id = MIN_ID, .scale = HapticGenerator::VibratorScale::VERY_LOW};

const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScale = {

        .id = 1, .scale = HapticGenerator::VibratorScale::LOW};

const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScaleNew = {

        .id = 1, .scale = HapticGenerator::VibratorScale::NONE};

const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScaleWithMaxId = {

        .id = MAX_ID, .scale = HapticGenerator::VibratorScale::VERY_HIGH};

const HapticGenerator::HapticScale HapticGeneratorScalesTest::kHapticScaleWithMaxIdNew = {

        .id = MAX_ID, .scale = HapticGenerator::VibratorScale::MUTE};



TEST_P(HapticGeneratorScalesTest, SetAndUpdateOne) {

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScale}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleNew}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMinIdNew}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMaxId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMaxIdNew}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



TEST_P(HapticGeneratorScalesTest, SetAndUpdateVector) {

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScale, kHapticScaleWithMaxId, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam(

            {kHapticScaleNew, kHapticScaleWithMaxIdNew, kHapticScaleWithMinIdNew}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



TEST_P(HapticGeneratorScalesTest, SetAndUpdateMultipleVector) {

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScale, kHapticScaleWithMaxId, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam(

            {kHapticScaleNew, kHapticScaleWithMaxIdNew, kHapticScaleWithMinIdNew}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScale, kHapticScaleWithMaxId, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



TEST_P(HapticGeneratorScalesTest, SetOneAndAddMoreVector) {

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScale}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMaxId, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



TEST_P(HapticGeneratorScalesTest, SetMultipleAndAddOneVector) {

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScaleWithMaxId, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(addHapticScaleParam({kHapticScale}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



TEST_P(HapticGeneratorScalesTest, SetMultipleVectorRepeat) {

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScaleWithMaxId, kHapticScale, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScaleWithMaxId, kHapticScale, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());

    EXPECT_NO_FATAL_FAILURE(

            addHapticScaleParam({kHapticScaleWithMaxId, kHapticScale, kHapticScaleWithMinId}));

    EXPECT_NO_FATAL_FAILURE(SetHapticScaleParameters());



    EXPECT_NO_FATAL_FAILURE(checkHapticScaleParameter());

}



INSTANTIATE_TEST_SUITE_P(

        HapticGeneratorScalesTest, HapticGeneratorScalesTest,

        ::testing::Combine(testing::ValuesIn(EffectFactoryHelper::getAllEffectDescriptors(

                IFactory::descriptor, kHapticGeneratorTypeUUID))),

        [](const testing::TestParamInfo<HapticGeneratorScalesTest::ParamType>& info) {

            auto descriptor = std::get<PARAM_INSTANCE_NAME>(info.param).second;

            std::string name = "Implementor_" + descriptor.common.implementor + "_name_" +

                               descriptor.common.name + "_UUID_" +

                               descriptor.common.id.uuid.toString();

            std::replace_if(

                    name.begin(), name.end(), [](const char c) { return !std::isalnum(c); }, '_');

            return name;

        });

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HapticGeneratorScalesTest);



int main(int argc, char** argv) {

    ::testing::InitGoogleTest(&argc, argv);

    ABinderProcess_setThreadPoolMaxThreadCount(1);