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
Loading
Loading
Loading
Loading
+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
+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: {
+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
+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));
}

// -------------------------------------------------------------------------
+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
Loading