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

Commit 27e69247 authored by Ytai Ben-tsvi's avatar Ytai Ben-tsvi Committed by Android (Google) Code Review
Browse files

Merge changes from topic "aidlize-aps" 

* changes:
  Convert IAudioPolicyService to AIDL
  Small changes around AIDL conversion code
parents f83ecd2c 0a4904a1

media/libaudioclient/AidlConversion.cpp

+39 −109
Original line number Diff line number Diff line
@@ -31,86 +31,6 @@ using base::unexpected; 


namespace {



////////////////////////////////////////////////////////////////////////////////////////////////////

// The code below establishes:

// IntegralTypeOf<T>, which works for either integral types (in which case it evaluates to T), or

// enum types (in which case it evaluates to std::underlying_type_T<T>).



template<typename T, typename = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>

struct IntegralTypeOfStruct {

    using Type = T;

};



template<typename T>

struct IntegralTypeOfStruct<T, std::enable_if_t<std::is_enum_v<T>>> {

    using Type = std::underlying_type_t<T>;

};



template<typename T>

using IntegralTypeOf = typename IntegralTypeOfStruct<T>::Type;



////////////////////////////////////////////////////////////////////////////////////////////////////

// Utilities for handling bitmasks.



template<typename Enum>

Enum index2enum_index(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(index);

}



template<typename Enum>

Enum index2enum_bitmask(int index) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    return static_cast<Enum>(1 << index);

}



template<typename Mask, typename Enum>

Mask enumToMask_bitmask(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(e);

}



template<typename Mask, typename Enum>

Mask enumToMask_index(Enum e) {

    static_assert(std::is_enum_v<Enum> || std::is_integral_v<Enum>);

    static_assert(std::is_enum_v<Mask> || std::is_integral_v<Mask>);

    return static_cast<Mask>(static_cast<std::make_unsigned_t<IntegralTypeOf<Mask>>>(1)

            << static_cast<int>(e));

}



template<typename DestMask, typename SrcMask, typename DestEnum, typename SrcEnum>

ConversionResult<DestMask> convertBitmask(

        SrcMask src, const std::function<ConversionResult<DestEnum>(SrcEnum)>& enumConversion,

        const std::function<SrcEnum(int)>& srcIndexToEnum,

        const std::function<DestMask(DestEnum)>& destEnumToMask) {

    using UnsignedDestMask = std::make_unsigned_t<IntegralTypeOf<DestMask>>;

    using UnsignedSrcMask = std::make_unsigned_t<IntegralTypeOf<SrcMask>>;



    UnsignedDestMask dest = static_cast<UnsignedDestMask>(0);

    UnsignedSrcMask usrc = static_cast<UnsignedSrcMask>(src);



    int srcBitIndex = 0;

    while (usrc != 0) {

        if (usrc & 1) {

            SrcEnum srcEnum = srcIndexToEnum(srcBitIndex);

            DestEnum destEnum = VALUE_OR_RETURN(enumConversion(srcEnum));

            DestMask destMask = destEnumToMask(destEnum);

            dest |= destMask;

        }

        ++srcBitIndex;

        usrc >>= 1;

    }

    return static_cast<DestMask>(dest);

}



template<typename Mask, typename Enum>

bool bitmaskIsSet(Mask mask, Enum index) {

    return (mask & enumToMask_index<Mask, Enum>(index)) != 0;

}



////////////////////////////////////////////////////////////////////////////////////////////////////



enum class Direction {

    INPUT, OUTPUT

};
@@ -318,7 +238,7 @@ ConversionResult<unsigned int> aidl2legacy_int32_t_config_mask(int32_t aidl) { 
    return convertBitmask<unsigned int, int32_t, int, media::AudioPortConfigType>(

            aidl, aidl2legacy_AudioPortConfigType_int32_t,

            // AudioPortConfigType enum is index-based.

            index2enum_index<media::AudioPortConfigType>,

            indexToEnum_index<media::AudioPortConfigType>,

            // AUDIO_PORT_CONFIG_* flags are mask-based.

            enumToMask_bitmask<unsigned int, int>);

}
@@ -327,7 +247,7 @@ ConversionResult<int32_t> legacy2aidl_config_mask_int32_t(unsigned int legacy) { 
    return convertBitmask<int32_t, unsigned int, media::AudioPortConfigType, int>(

            legacy, legacy2aidl_int32_t_AudioPortConfigType,

            // AUDIO_PORT_CONFIG_* flags are mask-based.

            index2enum_bitmask<unsigned>,

            indexToEnum_bitmask<unsigned>,

            // AudioPortConfigType enum is index-based.

            enumToMask_index<int32_t, media::AudioPortConfigType>);

}
@@ -494,7 +414,7 @@ ConversionResult<audio_gain_mode_t> aidl2legacy_int32_t_audio_gain_mode_t_mask(i 
    return convertBitmask<audio_gain_mode_t, int32_t, audio_gain_mode_t, media::AudioGainMode>(

            aidl, aidl2legacy_AudioGainMode_audio_gain_mode_t,

            // AudioGainMode is index-based.

            index2enum_index<media::AudioGainMode>,

            indexToEnum_index<media::AudioGainMode>,

            // AUDIO_GAIN_MODE_* constants are mask-based.

            enumToMask_bitmask<audio_gain_mode_t, audio_gain_mode_t>);

}
@@ -503,7 +423,7 @@ ConversionResult<int32_t> legacy2aidl_audio_gain_mode_t_int32_t_mask(audio_gain_ 
    return convertBitmask<int32_t, audio_gain_mode_t, media::AudioGainMode, audio_gain_mode_t>(

            legacy, legacy2aidl_audio_gain_mode_t_AudioGainMode,

            // AUDIO_GAIN_MODE_* constants are mask-based.

            index2enum_bitmask<audio_gain_mode_t>,

            indexToEnum_bitmask<audio_gain_mode_t>,

            // AudioGainMode is index-based.

            enumToMask_index<int32_t, media::AudioGainMode>);

}
@@ -695,7 +615,7 @@ ConversionResult<audio_input_flags_t> aidl2legacy_int32_t_audio_input_flags_t_ma 
    LegacyMask converted = VALUE_OR_RETURN(

            (convertBitmask<LegacyMask, int32_t, audio_input_flags_t, media::AudioInputFlags>(

                    aidl, aidl2legacy_AudioInputFlags_audio_input_flags_t,

                    index2enum_index<media::AudioInputFlags>,

                    indexToEnum_index<media::AudioInputFlags>,

                    enumToMask_bitmask<LegacyMask, audio_input_flags_t>)));

    return static_cast<audio_input_flags_t>(converted);

}
@@ -707,7 +627,7 @@ ConversionResult<int32_t> legacy2aidl_audio_input_flags_t_int32_t_mask( 
    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioInputFlags, audio_input_flags_t>(

            legacyMask, legacy2aidl_audio_input_flags_t_AudioInputFlags,

            index2enum_bitmask<audio_input_flags_t>,

            indexToEnum_bitmask<audio_input_flags_t>,

            enumToMask_index<int32_t, media::AudioInputFlags>);

}
@@ -718,7 +638,7 @@ ConversionResult<audio_output_flags_t> aidl2legacy_int32_t_audio_output_flags_t_ 
            audio_output_flags_t,

            media::AudioOutputFlags>(

            aidl, aidl2legacy_AudioOutputFlags_audio_output_flags_t,

            index2enum_index<media::AudioOutputFlags>,

            indexToEnum_index<media::AudioOutputFlags>,

            enumToMask_bitmask<audio_output_flags_t, audio_output_flags_t>);

}
@@ -729,7 +649,7 @@ ConversionResult<int32_t> legacy2aidl_audio_output_flags_t_int32_t_mask( 
    LegacyMask legacyMask = static_cast<LegacyMask>(legacy);

    return convertBitmask<int32_t, LegacyMask, media::AudioOutputFlags, audio_output_flags_t>(

            legacyMask, legacy2aidl_audio_output_flags_t_AudioOutputFlags,

            index2enum_bitmask<audio_output_flags_t>,

            indexToEnum_bitmask<audio_output_flags_t>,

            enumToMask_index<int32_t, media::AudioOutputFlags>);

}
@@ -1468,7 +1388,7 @@ legacy2aidl_audio_flags_mask_t_AudioFlag(audio_flags_mask_t legacy) { 
ConversionResult<audio_flags_mask_t>

aidl2legacy_int32_t_audio_flags_mask_t_mask(int32_t aidl) {

    return convertBitmask<audio_flags_mask_t, int32_t, audio_flags_mask_t, media::AudioFlag>(

            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, index2enum_index<media::AudioFlag>,

            aidl, aidl2legacy_AudioFlag_audio_flags_mask_t, indexToEnum_index<media::AudioFlag>,

            enumToMask_bitmask<audio_flags_mask_t, audio_flags_mask_t>);

}
@@ -1476,7 +1396,7 @@ ConversionResult<int32_t> 
legacy2aidl_audio_flags_mask_t_int32_t_mask(audio_flags_mask_t legacy) {

    return convertBitmask<int32_t, audio_flags_mask_t, media::AudioFlag, audio_flags_mask_t>(

            legacy, legacy2aidl_audio_flags_mask_t_AudioFlag,

            index2enum_bitmask<audio_flags_mask_t>,

            indexToEnum_bitmask<audio_flags_mask_t>,

            enumToMask_index<int32_t, media::AudioFlag>);

}
@@ -1783,7 +1703,7 @@ aidl2legacy_AudioEncapsulationMode_mask(int32_t aidl) { 
            audio_encapsulation_mode_t,

            media::AudioEncapsulationMode>(

            aidl, aidl2legacy_AudioEncapsulationMode_audio_encapsulation_mode_t,

            index2enum_index<media::AudioEncapsulationMode>,

            indexToEnum_index<media::AudioEncapsulationMode>,

            enumToMask_index<uint32_t, audio_encapsulation_mode_t>);

}
@@ -1794,7 +1714,7 @@ legacy2aidl_AudioEncapsulationMode_mask(uint32_t legacy) { 
            media::AudioEncapsulationMode,

            audio_encapsulation_mode_t>(

            legacy, legacy2aidl_audio_encapsulation_mode_t_AudioEncapsulationMode,

            index2enum_index<audio_encapsulation_mode_t>,

            indexToEnum_index<audio_encapsulation_mode_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMode>);

}
@@ -1805,7 +1725,7 @@ aidl2legacy_AudioEncapsulationMetadataType_mask(int32_t aidl) { 
            audio_encapsulation_metadata_type_t,

            media::AudioEncapsulationMetadataType>(

            aidl, aidl2legacy_AudioEncapsulationMetadataType_audio_encapsulation_metadata_type_t,

            index2enum_index<media::AudioEncapsulationMetadataType>,

            indexToEnum_index<media::AudioEncapsulationMetadataType>,

            enumToMask_index<uint32_t, audio_encapsulation_metadata_type_t>);

}
@@ -1816,7 +1736,7 @@ legacy2aidl_AudioEncapsulationMetadataType_mask(uint32_t legacy) { 
            media::AudioEncapsulationMetadataType,

            audio_encapsulation_metadata_type_t>(

            legacy, legacy2aidl_audio_encapsulation_metadata_type_t_AudioEncapsulationMetadataType,

            index2enum_index<audio_encapsulation_metadata_type_t>,

            indexToEnum_index<audio_encapsulation_metadata_type_t>,

            enumToMask_index<int32_t, media::AudioEncapsulationMetadataType>);

}
@@ -2197,4 +2117,14 @@ legacy2aidl_volume_group_t_int32_t(volume_group_t legacy) { 
    return convertReinterpret<int32_t>(legacy);

}



ConversionResult<product_strategy_t>

aidl2legacy_int32_t_product_strategy_t(int32_t aidl) {

    return convertReinterpret<product_strategy_t>(aidl);

}



ConversionResult<int32_t>

legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy) {

    return convertReinterpret<int32_t>(legacy);

}



}  // namespace android

media/libaudioclient/Android.bp

+62 −4
Original line number Diff line number Diff line
@@ -37,11 +37,16 @@ cc_library_shared { 
        "AudioPolicy.cpp",

        "AudioProductStrategy.cpp",

        "AudioVolumeGroup.cpp",

        "PolicyAidlConversion.cpp"

    ],

    shared_libs: [

        "audioclient-types-aidl-unstable-cpp",

        "audioflinger-aidl-unstable-cpp",

        "capture_state_listener-aidl-cpp",

        "audiopolicy-aidl-unstable-cpp",

        "audiopolicy-types-aidl-unstable-cpp",

        "capture_state_listener-aidl-unstable-cpp",

        "libaudiofoundation",

        "libaudioclient_aidl_conversion",

        "libaudioutils",

        "libbinder",

        "libcutils",
@@ -55,8 +60,13 @@ cc_library_shared { 
    include_dirs: ["system/media/audio_utils/include"],

    export_include_dirs: ["include"],

    export_shared_lib_headers: [

        "audioclient-types-aidl-unstable-cpp",

        "audioflinger-aidl-unstable-cpp",

        "capture_state_listener-aidl-cpp",

        "audiopolicy-aidl-unstable-cpp",

        "audiopolicy-types-aidl-unstable-cpp",

        "capture_state_listener-aidl-unstable-cpp",

        "libaudiofoundation",

        "libaudioclient_aidl_conversion",

    ],

    header_libs: ["libaudioclient_headers"],

}
@@ -84,7 +94,6 @@ cc_library { 
        "AudioTrack.cpp",

        "AudioTrackShared.cpp",

        "IAudioFlinger.cpp",

        "IAudioPolicyService.cpp",

        "ToneGenerator.cpp",

        "PlayerBase.cpp",

        "RecordingActivityTracker.cpp",
@@ -94,8 +103,9 @@ cc_library { 
        "audioclient-types-aidl-unstable-cpp",

        "audioflinger-aidl-unstable-cpp",

        "audiopolicy-aidl-unstable-cpp",

        "audiopolicy-types-aidl-unstable-cpp",

        "av-types-aidl-unstable-cpp",

        "capture_state_listener-aidl-cpp",

        "capture_state_listener-aidl-unstable-cpp",

        "libaudioclient_aidl_conversion",

        "libaudiofoundation",

        "libaudioutils",
@@ -247,6 +257,9 @@ aidl_interface { 
    name: "capture_state_listener-aidl",

    unstable: true,

    local_include_dir: "aidl",

    host_supported: true,

    double_loadable: true,

    vendor_available: true,

    srcs: [

        "aidl/android/media/ICaptureStateListener.aidl",

    ],
@@ -333,6 +346,44 @@ aidl_interface { 
        },

    },

}

aidl_interface {

    name: "audiopolicy-types-aidl",

    unstable: true,

    host_supported: true,

    vendor_available: true,

    double_loadable: true,

    local_include_dir: "aidl",

    srcs: [

        "aidl/android/media/AudioAttributesEx.aidl",

        "aidl/android/media/AudioMix.aidl",

        "aidl/android/media/AudioMixCallbackFlag.aidl",

        "aidl/android/media/AudioMixMatchCriterion.aidl",

        "aidl/android/media/AudioMixMatchCriterionValue.aidl",

        "aidl/android/media/AudioMixRouteFlag.aidl",

        "aidl/android/media/AudioMixType.aidl",

        "aidl/android/media/AudioOffloadMode.aidl",

        "aidl/android/media/AudioPolicyDeviceState.aidl",

        "aidl/android/media/AudioPolicyForceUse.aidl",

        "aidl/android/media/AudioPolicyForcedConfig.aidl",

        "aidl/android/media/AudioProductStrategy.aidl",

        "aidl/android/media/AudioVolumeGroup.aidl",

        "aidl/android/media/DeviceRole.aidl",

        "aidl/android/media/SoundTriggerSession.aidl",

    ],

    imports: [

        "audio_common-aidl",

        "audioclient-types-aidl",

    ],

    backend: {

        cpp: {

            min_sdk_version: "29",

            apex_available: [

                "//apex_available:platform",

                "com.android.media",

            ],

        },

    },

}



aidl_interface {

    name: "audioflinger-aidl",
@@ -385,12 +436,19 @@ aidl_interface { 
    host_supported: true,

    vendor_available: true,

    srcs: [

        "aidl/android/media/GetInputForAttrResponse.aidl",

        "aidl/android/media/GetOutputForAttrResponse.aidl",

        "aidl/android/media/Int.aidl",

        "aidl/android/media/RecordClientInfo.aidl",



        "aidl/android/media/IAudioPolicyService.aidl",

        "aidl/android/media/IAudioPolicyServiceClient.aidl",

    ],

    imports: [

        "audio_common-aidl",

        "audioclient-types-aidl",

        "audiopolicy-types-aidl",

        "capture_state_listener-aidl",

    ],

    double_loadable: true,

    backend: {

media/libaudioclient/AudioAttributes.cpp

+34 −36
Original line number Diff line number Diff line
@@ -20,48 +20,46 @@ 


#include <binder/Parcel.h>



#include <media/AidlConversion.h>

#include <media/AudioAttributes.h>

#include <media/PolicyAidlConversion.h>



#define RETURN_STATUS_IF_ERROR(x) \

    { auto _tmp = (x); if (_tmp != OK) return _tmp; }



namespace android {



status_t AudioAttributes::readFromParcel(const Parcel *parcel)

{

    status_t ret = NO_ERROR;

    mAttributes.content_type = static_cast<audio_content_type_t>(parcel->readInt32());

    mAttributes.usage = static_cast<audio_usage_t>(parcel->readInt32());

    mAttributes.source = static_cast<audio_source_t>(parcel->readInt32());

    mAttributes.flags = static_cast<audio_flags_mask_t>(parcel->readInt32());

    const bool hasFlattenedTag = (parcel->readInt32() == 1);

    if (hasFlattenedTag) {

        std::string tags;

        ret = parcel->readUtf8FromUtf16(&tags);

        if (ret != NO_ERROR) {

            return ret;

        }

        std::strncpy(mAttributes.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);

    } else {

        strcpy(mAttributes.tags, "");

status_t AudioAttributes::readFromParcel(const Parcel* parcel) {

    media::AudioAttributesEx aidl;

    RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));

    *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioAttributesEx_AudioAttributes(aidl));

    return OK;

}

    mStreamType = static_cast<audio_stream_type_t>(parcel->readInt32());

    mGroupId = static_cast<volume_group_t>(parcel->readUint32());

    return NO_ERROR;



status_t AudioAttributes::writeToParcel(Parcel* parcel) const {

    media::AudioAttributesEx aidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_AudioAttributes_AudioAttributesEx(*this));

    return aidl.writeToParcel(parcel);

}



status_t AudioAttributes::writeToParcel(Parcel *parcel) const

{

    parcel->writeInt32(static_cast<int32_t>(mAttributes.content_type));

    parcel->writeInt32(static_cast<int32_t>(mAttributes.usage));

    parcel->writeInt32(static_cast<int32_t>(mAttributes.source));

    parcel->writeInt32(static_cast<int32_t>(mAttributes.flags));

    if (strlen(mAttributes.tags) == 0) {

        parcel->writeInt32(0);

    } else {

        parcel->writeInt32(1);

        parcel->writeUtf8AsUtf16(std::string(mAttributes.tags));

ConversionResult<media::AudioAttributesEx>

legacy2aidl_AudioAttributes_AudioAttributesEx(const AudioAttributes& legacy) {

    media::AudioAttributesEx aidl;

    aidl.attributes = VALUE_OR_RETURN(

            legacy2aidl_audio_attributes_t_AudioAttributesInternal(legacy.getAttributes()));

    aidl.streamType = VALUE_OR_RETURN(

            legacy2aidl_audio_stream_type_t_AudioStreamType(legacy.getStreamType()));

    aidl.groupId = VALUE_OR_RETURN(legacy2aidl_volume_group_t_int32_t(legacy.getGroupId()));

    return aidl;

}

    parcel->writeInt32(static_cast<int32_t>(mStreamType));

    parcel->writeUint32(static_cast<uint32_t>(mGroupId));

    return NO_ERROR;



ConversionResult<AudioAttributes>

aidl2legacy_AudioAttributesEx_AudioAttributes(const media::AudioAttributesEx& aidl) {

    return AudioAttributes(VALUE_OR_RETURN(aidl2legacy_int32_t_volume_group_t(aidl.groupId)),

                           VALUE_OR_RETURN(aidl2legacy_AudioStreamType_audio_stream_type_t(

                                   aidl.streamType)),

                           VALUE_OR_RETURN(aidl2legacy_AudioAttributesInternal_audio_attributes_t(

                                   aidl.attributes)));

}



} // namespace android

media/libaudioclient/AudioEffect.cpp

+53 −5
Original line number Diff line number Diff line
@@ -23,15 +23,25 @@ 
#include <sys/types.h>

#include <limits.h>



#include <android/media/IAudioPolicyService.h>

#include <binder/IPCThreadState.h>

#include <media/AidlConversion.h>

#include <media/AudioEffect.h>

#include <media/PolicyAidlConversion.h>

#include <media/ShmemCompat.h>

#include <private/media/AudioEffectShared.h>

#include <utils/Log.h>



#define RETURN_STATUS_IF_ERROR(x)    \

    {                                \

        auto _tmp = (x);             \

        if (_tmp != OK) return _tmp; \

    }



namespace android {

using aidl_utils::statusTFromBinderStatus;

using binder::Status;

using media::IAudioPolicyService;



namespace {
@@ -539,9 +549,23 @@ status_t AudioEffect::queryDefaultPreProcessing(audio_session_t audioSession, 
                                          effect_descriptor_t *descriptors,

                                          uint32_t *count)

{

    if (descriptors == nullptr || count == nullptr) {

        return BAD_VALUE;

    }

    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;

    return aps->queryDefaultPreProcessing(audioSession, descriptors, count);



    int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_session_t_int32_t(audioSession));

    media::Int countAidl;

    countAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*count));

    std::vector<media::EffectDescriptor> retAidl;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            aps->queryDefaultPreProcessing(audioSessionAidl, &countAidl, &retAidl)));

    *count = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(countAidl.value));

    RETURN_STATUS_IF_ERROR(convertRange(retAidl.begin(), retAidl.end(), descriptors,

                                        aidl2legacy_EffectDescriptor_effect_descriptor_t));

    return OK;

}



status_t AudioEffect::newEffectUniqueId(audio_unique_id_t* id)
@@ -581,7 +605,18 @@ status_t AudioEffect::addSourceDefaultEffect(const char *typeStr, 
        uuid = *EFFECT_UUID_NULL;

    }



    return aps->addSourceDefaultEffect(&type, opPackageName, &uuid, priority, source, id);

    media::AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));

    media::AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));

    std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_String16_string(opPackageName));

    media::AudioSourceType sourceAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_source_t_AudioSourceType(source));

    int32_t retAidl;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            aps->addSourceDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, sourceAidl,

                                        &retAidl)));

    *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));

    return OK;

}



status_t AudioEffect::addStreamDefaultEffect(const char *typeStr,
@@ -613,7 +648,18 @@ status_t AudioEffect::addStreamDefaultEffect(const char *typeStr, 
        uuid = *EFFECT_UUID_NULL;

    }



    return aps->addStreamDefaultEffect(&type, opPackageName, &uuid, priority, usage, id);

    media::AudioUuid typeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(type));

    media::AudioUuid uuidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_uuid_t_AudioUuid(uuid));

    std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_String16_string(opPackageName));

    media::AudioUsage usageAidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_audio_usage_t_AudioUsage(usage));

    int32_t retAidl;

    RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(

            aps->addStreamDefaultEffect(typeAidl, opPackageNameAidl, uuidAidl, priority, usageAidl,

                                        &retAidl)));

    *id = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_unique_id_t(retAidl));

    return OK;

}



status_t AudioEffect::removeSourceDefaultEffect(audio_unique_id_t id)
@@ -621,7 +667,8 @@ status_t AudioEffect::removeSourceDefaultEffect(audio_unique_id_t id) 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    return aps->removeSourceDefaultEffect(id);

    int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));

    return statusTFromBinderStatus(aps->removeSourceDefaultEffect(idAidl));

}



status_t AudioEffect::removeStreamDefaultEffect(audio_unique_id_t id)
@@ -629,7 +676,8 @@ status_t AudioEffect::removeStreamDefaultEffect(audio_unique_id_t id) 
    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return PERMISSION_DENIED;



    return aps->removeStreamDefaultEffect(id);

    int32_t idAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));

    return statusTFromBinderStatus(aps->removeStreamDefaultEffect(idAidl));

}



// -------------------------------------------------------------------------

media/libaudioclient/AudioProductStrategy.cpp

+35 −43
Original line number Diff line number Diff line
@@ -19,55 +19,47 @@ 
#include <utils/Log.h>

#include <media/AudioProductStrategy.h>

#include <media/AudioAttributes.h>

#include <media/AudioSystem.h>

#include <media/PolicyAidlConversion.h>



#define RETURN_STATUS_IF_ERROR(x) \

    { auto _tmp = (x); if (_tmp != OK) return _tmp; }



namespace android {



status_t AudioProductStrategy::readFromParcel(const Parcel *parcel)

{

    mId = static_cast<product_strategy_t>(parcel->readInt32());

    status_t ret = parcel->readUtf8FromUtf16(&mName);

    if (ret != NO_ERROR) {

        return ret;

    }

    size_t size = static_cast<size_t>(parcel->readInt32());

    for (size_t i = 0; i < size; i++) {

        AudioAttributes attribute;

        ret = attribute.readFromParcel(parcel);

        if (ret != NO_ERROR) {

            mAudioAttributes.clear();

            return ret;

        }

        mAudioAttributes.push_back(attribute);

    }

    return NO_ERROR;

status_t AudioProductStrategy::readFromParcel(const Parcel* parcel) {

    media::AudioProductStrategy aidl;

    RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));

    *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioProductStrategy(aidl));

    return OK;

}



status_t AudioProductStrategy::writeToParcel(Parcel *parcel) const

{

    parcel->writeInt32(static_cast<int32_t>(mId));

    parcel->writeUtf8AsUtf16(mName);

    size_t size = mAudioAttributes.size();

    size_t sizePosition = parcel->dataPosition();

    parcel->writeInt32(size);

    size_t finalSize = size;



    for (size_t i = 0; i < size; i++) {

        size_t position = parcel->dataPosition();

        AudioAttributes attribute(mAudioAttributes[i]);

        status_t ret = attribute.writeToParcel(parcel);

        if (ret != NO_ERROR) {

            parcel->setDataPosition(position);

            finalSize--;

        }

status_t AudioProductStrategy::writeToParcel(Parcel* parcel) const {

    media::AudioProductStrategy aidl = VALUE_OR_RETURN_STATUS(

            legacy2aidl_AudioProductStrategy(*this));

    return aidl.writeToParcel(parcel);

}

    if (size != finalSize) {

        size_t position = parcel->dataPosition();

        parcel->setDataPosition(sizePosition);

        parcel->writeInt32(finalSize);

        parcel->setDataPosition(position);



ConversionResult<media::AudioProductStrategy>

legacy2aidl_AudioProductStrategy(const AudioProductStrategy& legacy) {

    media::AudioProductStrategy aidl;

    aidl.name = legacy.getName();

    aidl.audioAttributes = VALUE_OR_RETURN(

            convertContainer<std::vector<media::AudioAttributesEx>>(

                    legacy.getAudioAttributes(),

                    legacy2aidl_AudioAttributes_AudioAttributesEx));

    aidl.id = VALUE_OR_RETURN(legacy2aidl_product_strategy_t_int32_t(legacy.getId()));

    return aidl;

}

    return NO_ERROR;



ConversionResult<AudioProductStrategy>

aidl2legacy_AudioProductStrategy(const media::AudioProductStrategy& aidl) {

    return AudioProductStrategy(

            aidl.name,

            VALUE_OR_RETURN(

                    convertContainer<std::vector<AudioAttributes>>(

                            aidl.audioAttributes,

                            aidl2legacy_AudioAttributesEx_AudioAttributes)),

            VALUE_OR_RETURN(aidl2legacy_int32_t_product_strategy_t(aidl.id)));

}



// Keep in sync with android/media/audiopolicy/AudioProductStrategy#attributeMatches