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

Commit 0a4904a1 authored by Ytai Ben-Tsvi's avatar Ytai Ben-Tsvi
Browse files

Convert IAudioPolicyService to AIDL 

Test: Audio tests from CtsMediaTests
Test: Audio smoke tests
Bug: 160253486

Change-Id: I5ecee56f71a959d2fd75714ba95d7653af0c98bc
parent 08c7d9e6

media/libaudioclient/AidlConversion.cpp

+10 −0
Original line number Diff line number Diff line
@@ -2117,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