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

Commit a893389e authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

Audio CAP: Address ANAPIC comments, Part 3. 

Use the new definition of 'AudioPolicyForceUse' from
android.media.audio.common stable AIDL package.

Instead of a loosely coupled pair of values from the enum
'AudioPolicyForceUse' and the associated enum
'AudioPolicyForcedConfig', there is now a single union
'AudioPolicyForceUse'. The tag of this union replaces the enum
named the same, while the value of the union replaces
'AudioPolicyForcedConfig'. Possible values for uses got limited
to the pairs that actually make sense.

For consistency, `forceUse` field was removed from
'AudioHalCapCriterionV2::ForceConfigForUse'. Instead, the tag
from the first element of 'values' is used for specifying
the use case.

Bug: 364310317
Test: m
Change-Id: I9c06f8988ee0128651d078f8d613489715b2581c
parent 2850b261

services/audiopolicy/engineconfigurable/config/src/CapEngineConfig.cpp

+184 −24
Original line number Original line Diff line number Diff line
@@ -41,21 +41,23 @@ 




namespace android {

namespace android {





using utilities::convertTo;

using base::unexpected;

using media::audio::common::AudioDeviceAddress;

using media::audio::common::AudioDeviceAddress;

using media::audio::common::AudioDeviceDescription;

using media::audio::common::AudioDeviceDescription;

using media::audio::common::AudioHalCapCriterion;

using media::audio::common::AudioHalCapCriterion;

using media::audio::common::AudioHalCapCriterionV2;

using media::audio::common::AudioHalCapParameter;

using media::audio::common::AudioHalCapParameter;

using media::audio::common::AudioHalCapRule;

using media::audio::common::AudioHalCapRule;

using media::audio::common::AudioPolicyForceUse;

using media::audio::common::AudioSource;

using media::audio::common::AudioSource;

using media::audio::common::AudioStreamType;

using media::audio::common::AudioStreamType;

using media::audio::common::AudioHalCapCriterionV2;

using utilities::convertTo;

using ::android::base::unexpected;





namespace capEngineConfig {

namespace capEngineConfig {





static constexpr const char *gLegacyOutputDevicePrefix = "AUDIO_DEVICE_OUT_";

static constexpr const char *gLegacyOutputDevicePrefix = "AUDIO_DEVICE_OUT_";

static constexpr const char *gLegacyInputDevicePrefix = "AUDIO_DEVICE_IN_";

static constexpr const char *gLegacyInputDevicePrefix = "AUDIO_DEVICE_IN_";

static constexpr const char *gLegacyForcePrefix = "AUDIO_POLICY_FORCE_";

static constexpr const char *gLegacyStreamPrefix = "AUDIO_STREAM_";

static constexpr const char *gLegacyStreamPrefix = "AUDIO_STREAM_";

static constexpr const char *gLegacySourcePrefix = "AUDIO_SOURCE_";

static constexpr const char *gLegacySourcePrefix = "AUDIO_SOURCE_";

static constexpr const char *gPolicyParamPrefix = "/Policy/policy/";

static constexpr const char *gPolicyParamPrefix = "/Policy/policy/";
@@ -83,6 +85,134 @@ ConversionResult<std::string> truncatePrefix(const std::string& name, const std 
    return capName;

    return capName;

}

}





ConversionResult<audio_policy_forced_cfg_t>

        aidl2legacy_AudioPolicyForceUseCommunicationDeviceCategory_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse::CommunicationDeviceCategory aidl) {

    switch (aidl) {

        case AudioPolicyForceUse::CommunicationDeviceCategory::NONE:

            return AUDIO_POLICY_FORCE_NONE;

        case AudioPolicyForceUse::CommunicationDeviceCategory::SPEAKER:

            return AUDIO_POLICY_FORCE_SPEAKER;

        case AudioPolicyForceUse::CommunicationDeviceCategory::BT_SCO:

            return AUDIO_POLICY_FORCE_BT_SCO;

        case AudioPolicyForceUse::CommunicationDeviceCategory::BT_BLE:

            return AUDIO_POLICY_FORCE_BT_BLE;

        case AudioPolicyForceUse::CommunicationDeviceCategory::WIRED_ACCESSORY:

            return AUDIO_POLICY_FORCE_WIRED_ACCESSORY;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_policy_forced_cfg_t>

        aidl2legacy_AudioPolicyForceUseMediaDeviceCategory_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse::MediaDeviceCategory aidl) {

    switch (aidl) {

        case AudioPolicyForceUse::MediaDeviceCategory::NONE:

            return AUDIO_POLICY_FORCE_NONE;

        case AudioPolicyForceUse::MediaDeviceCategory::SPEAKER:

            return AUDIO_POLICY_FORCE_SPEAKER;

        case AudioPolicyForceUse::MediaDeviceCategory::HEADPHONES:

            return AUDIO_POLICY_FORCE_HEADPHONES;

        case AudioPolicyForceUse::MediaDeviceCategory::BT_A2DP:

            return AUDIO_POLICY_FORCE_BT_A2DP;

        case AudioPolicyForceUse::MediaDeviceCategory::ANALOG_DOCK:

            return AUDIO_POLICY_FORCE_ANALOG_DOCK;

        case AudioPolicyForceUse::MediaDeviceCategory::DIGITAL_DOCK:

            return AUDIO_POLICY_FORCE_DIGITAL_DOCK;

        case AudioPolicyForceUse::MediaDeviceCategory::WIRED_ACCESSORY:

            return AUDIO_POLICY_FORCE_WIRED_ACCESSORY;

        case AudioPolicyForceUse::MediaDeviceCategory::NO_BT_A2DP:

            return AUDIO_POLICY_FORCE_NO_BT_A2DP;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_policy_forced_cfg_t>

        aidl2legacy_AudioPolicyForceUseDockType_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse::DockType aidl) {

    switch (aidl) {

        case AudioPolicyForceUse::DockType::NONE:

            return AUDIO_POLICY_FORCE_NONE;

        case AudioPolicyForceUse::DockType::BT_CAR_DOCK:

            return AUDIO_POLICY_FORCE_BT_CAR_DOCK;

        case AudioPolicyForceUse::DockType::BT_DESK_DOCK:

            return AUDIO_POLICY_FORCE_BT_DESK_DOCK;

        case AudioPolicyForceUse::DockType::ANALOG_DOCK:

            return AUDIO_POLICY_FORCE_ANALOG_DOCK;

        case AudioPolicyForceUse::DockType::DIGITAL_DOCK:

            return AUDIO_POLICY_FORCE_DIGITAL_DOCK;

        case AudioPolicyForceUse::DockType::WIRED_ACCESSORY:

            return AUDIO_POLICY_FORCE_WIRED_ACCESSORY;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<audio_policy_forced_cfg_t>

        aidl2legacy_AudioPolicyForceUseEncodedSurroundConfig_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse::EncodedSurroundConfig aidl) {

    switch (aidl) {

        case AudioPolicyForceUse::EncodedSurroundConfig::UNSPECIFIED:

            return AUDIO_POLICY_FORCE_NONE;

        case AudioPolicyForceUse::EncodedSurroundConfig::NEVER:

            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER;

        case AudioPolicyForceUse::EncodedSurroundConfig::ALWAYS:

            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS;

        case AudioPolicyForceUse::EncodedSurroundConfig::MANUAL:

            return AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL;

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<std::pair<audio_policy_force_use_t, audio_policy_forced_cfg_t>>

        aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse& aidl) {

    switch (aidl.getTag()) {

        case AudioPolicyForceUse::forCommunication:

            return std::make_pair(

                    AUDIO_POLICY_FORCE_FOR_COMMUNICATION,

                    VALUE_OR_RETURN(

                            aidl2legacy_AudioPolicyForceUseCommunicationDeviceCategory_audio_policy_forced_cfg_t(

                                    aidl.get<AudioPolicyForceUse::forCommunication>())));

        case AudioPolicyForceUse::forMedia:

            return std::make_pair(

                    AUDIO_POLICY_FORCE_FOR_MEDIA,

                    VALUE_OR_RETURN(

                            aidl2legacy_AudioPolicyForceUseMediaDeviceCategory_audio_policy_forced_cfg_t(

                                    aidl.get<AudioPolicyForceUse::forMedia>())));

        case AudioPolicyForceUse::forRecord:

            return std::make_pair(

                    AUDIO_POLICY_FORCE_FOR_RECORD,

                    VALUE_OR_RETURN(

                            aidl2legacy_AudioPolicyForceUseCommunicationDeviceCategory_audio_policy_forced_cfg_t(

                                    aidl.get<AudioPolicyForceUse::forRecord>())));

        case AudioPolicyForceUse::dock:

            return std::make_pair(AUDIO_POLICY_FORCE_FOR_DOCK,

                    VALUE_OR_RETURN(

                            aidl2legacy_AudioPolicyForceUseDockType_audio_policy_forced_cfg_t(

                                    aidl.get<AudioPolicyForceUse::dock>())));

        case AudioPolicyForceUse::systemSounds:

            return std::make_pair(AUDIO_POLICY_FORCE_FOR_SYSTEM,

                    aidl.get<AudioPolicyForceUse::systemSounds>() ?

                    AUDIO_POLICY_FORCE_SYSTEM_ENFORCED : AUDIO_POLICY_FORCE_NONE);

        case AudioPolicyForceUse::hdmiSystemAudio:

            return std::make_pair(

                    AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO,

                    aidl.get<AudioPolicyForceUse::hdmiSystemAudio>() ?

                    AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED : AUDIO_POLICY_FORCE_NONE);

        case AudioPolicyForceUse::encodedSurround:

            return std::make_pair(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, VALUE_OR_RETURN(

                aidl2legacy_AudioPolicyForceUseEncodedSurroundConfig_audio_policy_forced_cfg_t(

                        aidl.get<AudioPolicyForceUse::encodedSurround>())));

        case AudioPolicyForceUse::forVibrateRinging:

            return std::make_pair(

                    AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING,

                    VALUE_OR_RETURN(

                            aidl2legacy_AudioPolicyForceUseCommunicationDeviceCategory_audio_policy_forced_cfg_t(

                                    aidl.get<AudioPolicyForceUse::forVibrateRinging>())));

    }

    return unexpected(BAD_VALUE);

}



ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2_CapName(

ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2_CapName(

        const AudioHalCapCriterionV2& aidl) {

        const AudioHalCapCriterionV2& aidl) {

    switch (aidl.getTag()) {

    switch (aidl.getTag()) {
@@ -97,14 +227,14 @@ ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2_CapName( 
        case AudioHalCapCriterionV2::telephonyMode:

        case AudioHalCapCriterionV2::telephonyMode:

            return gPhoneStateCriterionName;

            return gPhoneStateCriterionName;

        case AudioHalCapCriterionV2::forceConfigForUse: {

        case AudioHalCapCriterionV2::forceConfigForUse: {

            auto aidlCriterion = aidl.get<AudioHalCapCriterionV2::forceConfigForUse>();

            auto aidlCriterion = aidl.get<AudioHalCapCriterionV2::forceConfigForUse>().values[0];

            return gForceUseCriterionTag[VALUE_OR_RETURN(

            const auto [forceUse, _] = VALUE_OR_RETURN(

                    aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(

                aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t_audio_policy_forced_cfg_t(

                            aidlCriterion.forceUse))];

                        aidlCriterion));

            return gForceUseCriterionTag[forceUse];

        }

        }

        default:

            return unexpected(BAD_VALUE);

    }

    }

    return unexpected(BAD_VALUE);

}

}





ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2TypeDevice_CapCriterionValue(

ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2TypeDevice_CapCriterionValue(
@@ -121,6 +251,32 @@ ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2TypeDevice_CapCr 
            isOut ? gLegacyOutputDevicePrefix : gLegacyInputDevicePrefix);

            isOut ? gLegacyOutputDevicePrefix : gLegacyInputDevicePrefix);

}

}





ConversionResult<audio_policy_forced_cfg_t>

        aidl2legacy_AudioHalCapCriterionV2ForceUse_audio_policy_forced_cfg_t(

        const AudioPolicyForceUse& aidl) {

    const auto [_, legacyForcedCfg] = VALUE_OR_RETURN(

            aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t_audio_policy_forced_cfg_t(

                    aidl));

    return legacyForcedCfg;

}



ConversionResult<std::string> audio_policy_forced_cfg_t_CapCriterionValue(

        audio_policy_forced_cfg_t legacyForcedCfg) {

    std::string legacyForcedCfgLiteral = audio_policy_forced_cfg_to_string(legacyForcedCfg);

    if (legacyForcedCfgLiteral.empty()) {

        ALOGE("%s Invalid forced config value %d", __func__, legacyForcedCfg);

        return unexpected(BAD_VALUE);

    }

    return truncatePrefix(legacyForcedCfgLiteral, gLegacyForcePrefix);

}



ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2ForceUse_CapCriterionValue(

        const AudioPolicyForceUse& aidl) {

    const audio_policy_forced_cfg_t legacyForcedCfg = VALUE_OR_RETURN(

            aidl2legacy_AudioHalCapCriterionV2ForceUse_audio_policy_forced_cfg_t(aidl));

    return audio_policy_forced_cfg_t_CapCriterionValue(legacyForcedCfg);

}



ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2Type_CapCriterionValue(

ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2Type_CapCriterionValue(

        const AudioHalCapCriterionV2& aidl) {

        const AudioHalCapCriterionV2& aidl) {

    switch (aidl.getTag()) {

    switch (aidl.getTag()) {
@@ -139,10 +295,10 @@ ConversionResult<std::string> aidl2legacy_AudioHalCapCriterionV2Type_CapCriterio 
        case AudioHalCapCriterionV2::telephonyMode:

        case AudioHalCapCriterionV2::telephonyMode:

            return toString(aidl.get<AudioHalCapCriterionV2::telephonyMode>().values[0]);

            return toString(aidl.get<AudioHalCapCriterionV2::telephonyMode>().values[0]);

        case AudioHalCapCriterionV2::forceConfigForUse:

        case AudioHalCapCriterionV2::forceConfigForUse:

            return toString(aidl.get<AudioHalCapCriterionV2::forceConfigForUse>().values[0]);

            return aidl2legacy_AudioHalCapCriterionV2ForceUse_CapCriterionValue(

        default:

                    aidl.get<AudioHalCapCriterionV2::forceConfigForUse>().values[0]);

            return unexpected(BAD_VALUE);

    }

    }

    return unexpected(BAD_VALUE);

}

}





ConversionResult<std::string> aidl2legacy_AudioHalCapRule_CapRule(

ConversionResult<std::string> aidl2legacy_AudioHalCapRule_CapRule(
@@ -333,22 +489,26 @@ ConversionResult<CapCriterion> aidl2legacy_AudioHalCapCriterionV2_Criterion( 




    auto loadForceUseCriterion = [](const auto& aidlCriterion, auto& criterion,

    auto loadForceUseCriterion = [](const auto& aidlCriterion, auto& criterion,

                                    auto& criterionType) -> status_t {

                                    auto& criterionType) -> status_t {

        uint32_t legacyForceUse = VALUE_OR_RETURN_STATUS(

        if (aidlCriterion.values.empty()) {

                aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(

            return BAD_VALUE;

                        aidlCriterion.forceUse));

        }

        const auto [legacyForceUse, _] = VALUE_OR_RETURN_STATUS(

                aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t_audio_policy_forced_cfg_t(

                        aidlCriterion.values[0]));

        criterion.typeName = criterionType.name;

        criterion.typeName = criterionType.name;

        criterionType.name = criterion.typeName + gCriterionTypeSuffix;

        criterionType.name = criterion.typeName + gCriterionTypeSuffix;

        criterionType.isInclusive =

        criterionType.isInclusive =

                (aidlCriterion.logic == AudioHalCapCriterionV2::LogicalDisjunction::INCLUSIVE);

                (aidlCriterion.logic == AudioHalCapCriterionV2::LogicalDisjunction::INCLUSIVE);

        criterion.name = gForceUseCriterionTag[legacyForceUse];

        criterion.name = gForceUseCriterionTag[legacyForceUse];

        criterion.defaultLiteralValue = toString(aidlCriterion.defaultValue);

        criterion.defaultLiteralValue = toString(

        if (aidlCriterion.values.empty()) {

                aidlCriterion.defaultValue.template get<AudioPolicyForceUse::forMedia>());

            return BAD_VALUE;

        }

        for (auto &value : aidlCriterion.values) {

        for (auto &value : aidlCriterion.values) {

            uint32_t legacyForcedConfig = VALUE_OR_RETURN_STATUS(

            const audio_policy_forced_cfg_t legacyForcedCfg = VALUE_OR_RETURN_STATUS(

                    aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(value));

                    aidl2legacy_AudioHalCapCriterionV2ForceUse_audio_policy_forced_cfg_t(value));

            criterionType.valuePairs.push_back({legacyForcedConfig, 0, toString(value)});

            const std::string legacyForcedCfgLiteral = VALUE_OR_RETURN_STATUS(

                    audio_policy_forced_cfg_t_CapCriterionValue(legacyForcedCfg));

            criterionType.valuePairs.push_back(

                    {legacyForcedCfg, 0, legacyForcedCfgLiteral});

        }

        }

        return NO_ERROR;

        return NO_ERROR;

    };

    };