Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-02 02:18:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Treehugger Robot
2023-01-03 18:19:16 +00:00
committed by Gerrit Code Review
parent 0f8849795f c7d237de07
commit fb6e7a8fb2
5 changed files with 241 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
audio/aidl/aidl_api/android.hardware.audio.effect/current/android/hardware/audio/effect/HapticGenerator.aidl
View File

@@ -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 {

2
audio/aidl/android/hardware/audio/effect/HapticGenerator.aidl
View File

@@ -90,6 +90,6 @@ union HapticGenerator {
float maxAmplitude;
}
HapticScale hapticScale;
HapticScale[] hapticScales;
VibratorInformation vibratorInfo;
}

24
audio/aidl/default/hapticGenerator/HapticGeneratorSw.cpp
View File

@@ -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

10
audio/aidl/default/hapticGenerator/HapticGeneratorSw.h
View File

@@ -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};
};

239
audio/aidl/vts/VtsHalHapticGeneratorTargetTest.cpp
View File

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