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

Commit 7e7a79d8 authored by Ytai Ben-Tsvi's avatar Ytai Ben-Tsvi
Browse files

AIDLize IAudioPolicyServiceClient 

Bug: 160253486
Test: Audio-related tests from CtsMediaTestCases
Change-Id: Id37fad4028b620620a45dabe8af068f3158e6228
parent 1601ba67

media/libaudioclient/AidlConversion.cpp

+10 −0
Original line number Diff line number Diff line
@@ -2187,4 +2187,14 @@ legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(audio_unique_id_use_t legacy) 
    return unexpected(BAD_VALUE);

}



ConversionResult<volume_group_t>

aidl2legacy_int32_t_volume_group_t(int32_t aidl) {

    return convertReinterpret<volume_group_t>(aidl);

}



ConversionResult<int32_t>

legacy2aidl_volume_group_t_int32_t(volume_group_t legacy) {

    return convertReinterpret<int32_t>(legacy);

}



}  // namespace android

media/libaudioclient/Android.bp

+31 −1
Original line number Diff line number Diff line
@@ -15,10 +15,12 @@ cc_library_headers { 
    ],

    static_libs: [

        "audioflinger-aidl-unstable-cpp",

        "audiopolicy-aidl-unstable-cpp",

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

    ],

    export_static_lib_headers: [

        "audioflinger-aidl-unstable-cpp",

        "audiopolicy-aidl-unstable-cpp",

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

    ],

    target: {
@@ -56,6 +58,7 @@ cc_library_shared { 
        "audioflinger-aidl-unstable-cpp",

        "capture_state_listener-aidl-cpp",

    ],

    header_libs: ["libaudioclient_headers"],

}



cc_library_shared {
@@ -82,7 +85,6 @@ cc_library_shared { 
        "AudioTrackShared.cpp",

        "IAudioFlinger.cpp",

        "IAudioPolicyService.cpp",

        "IAudioPolicyServiceClient.cpp",

        "ToneGenerator.cpp",

        "PlayerBase.cpp",

        "RecordingActivityTracker.cpp",
@@ -91,6 +93,7 @@ cc_library_shared { 
    shared_libs: [

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

        "audioflinger-aidl-unstable-cpp",

        "audiopolicy-aidl-unstable-cpp",

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

        "capture_state_listener-aidl-cpp",

        "libaudioclient_aidl_conversion",
@@ -113,6 +116,7 @@ cc_library_shared { 
    ],

    export_shared_lib_headers: [

        "audioflinger-aidl-unstable-cpp",

        "audiopolicy-aidl-unstable-cpp",

        "libbinder",

    ],
@@ -373,3 +377,29 @@ aidl_interface { 
        },

    },

}



aidl_interface {

    name: "audiopolicy-aidl",

    unstable: true,

    local_include_dir: "aidl",

    host_supported: true,

    vendor_available: true,

    srcs: [

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



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

    ],

    imports: [

        "audioclient-types-aidl",

    ],

    double_loadable: true,

    backend: {

        cpp: {

            min_sdk_version: "29",

            apex_available: [

                "//apex_available:platform",

                "com.android.media",

            ],

        },

    },

}

media/libaudioclient/AudioSystem.cpp

+75 −22
Original line number Diff line number Diff line
@@ -1792,20 +1792,22 @@ int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback( 
}





void AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate()

Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate()

{

    Mutex::Autolock _l(mLock);

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

        mAudioPortCallbacks[i]->onAudioPortListUpdate();

    }

    return Status::ok();

}



void AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate()

Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate()

{

    Mutex::Autolock _l(mLock);

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

        mAudioPortCallbacks[i]->onAudioPatchListUpdate();

    }

    return Status::ok();

}



// ----------------------------------------------------------------------------
@@ -1839,20 +1841,26 @@ int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback( 
    return mAudioVolumeGroupCallback.size();

}



void AudioSystem::AudioPolicyServiceClient::onAudioVolumeGroupChanged(volume_group_t group,

                                                                      int flags)

{

Status AudioSystem::AudioPolicyServiceClient::onAudioVolumeGroupChanged(int32_t group,

                                                                        int32_t flags) {

    volume_group_t groupLegacy = VALUE_OR_RETURN_BINDER_STATUS(

            aidl2legacy_int32_t_volume_group_t(group));

    int flagsLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(flags));



    Mutex::Autolock _l(mLock);

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

        mAudioVolumeGroupCallback[i]->onAudioVolumeGroupChanged(group, flags);

        mAudioVolumeGroupCallback[i]->onAudioVolumeGroupChanged(groupLegacy, flagsLegacy);

    }

    return Status::ok();

}

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



void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(

        String8 regId, int32_t state)

{

    ALOGV("AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(%s, %d)", regId.string(), state);

Status AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(

        const ::std::string& regId, int32_t state) {

    ALOGV("AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate(%s, %d)", regId.c_str(), state);



    String8 regIdLegacy = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_string_view_String8(regId));

    int stateLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(state));

    dynamic_policy_callback cb = NULL;

    {

        Mutex::Autolock _l(AudioSystem::gLock);
@@ -1860,19 +1868,20 @@ void AudioSystem::AudioPolicyServiceClient::onDynamicPolicyMixStateUpdate( 
    }



    if (cb != NULL) {

        cb(DYNAMIC_POLICY_EVENT_MIX_STATE_UPDATE, regId, state);

        cb(DYNAMIC_POLICY_EVENT_MIX_STATE_UPDATE, regIdLegacy, stateLegacy);

    }

    return Status::ok();

}



void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(

                                                int event,

                                                const record_client_info_t *clientInfo,

                                                const audio_config_base_t *clientConfig,

                                                std::vector<effect_descriptor_t> clientEffects,

                                                const audio_config_base_t *deviceConfig,

                                                std::vector<effect_descriptor_t> effects,

                                                audio_patch_handle_t patchHandle,

                                                audio_source_t source) {

Status AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate(

        int32_t event,

        const media::RecordClientInfo& clientInfo,

        const media::AudioConfigBase& clientConfig,

        const std::vector<media::EffectDescriptor>& clientEffects,

        const media::AudioConfigBase& deviceConfig,

        const std::vector<media::EffectDescriptor>& effects,

        int32_t patchHandle,

        media::AudioSourceType source) {

    record_config_callback cb = NULL;

    {

        Mutex::Autolock _l(AudioSystem::gLock);
@@ -1880,9 +1889,29 @@ void AudioSystem::AudioPolicyServiceClient::onRecordingConfigurationUpdate( 
    }



    if (cb != NULL) {

        cb(event, clientInfo, clientConfig, clientEffects,

           deviceConfig, effects, patchHandle, source);

        int eventLegacy = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(event));

        record_client_info_t clientInfoLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_RecordClientInfo_record_client_info_t(clientInfo));

        audio_config_base_t clientConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_AudioConfigBase_audio_config_base_t(clientConfig));

        std::vector<effect_descriptor_t> clientEffectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                convertContainer<std::vector<effect_descriptor_t>>(

                        clientEffects,

                        aidl2legacy_EffectDescriptor_effect_descriptor_t));

        audio_config_base_t deviceConfigLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_AudioConfigBase_audio_config_base_t(deviceConfig));

        std::vector<effect_descriptor_t> effectsLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                convertContainer<std::vector<effect_descriptor_t>>(

                        effects,

                        aidl2legacy_EffectDescriptor_effect_descriptor_t));

        audio_patch_handle_t patchHandleLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_int32_t_audio_patch_handle_t(patchHandle));

        audio_source_t sourceLegacy = VALUE_OR_RETURN_BINDER_STATUS(

                aidl2legacy_AudioSourceType_audio_source_t(source));

        cb(eventLegacy, &clientInfoLegacy, &clientConfigLegacy, clientEffectsLegacy,

           &deviceConfigLegacy, effectsLegacy, patchHandleLegacy, sourceLegacy);

    }

    return Status::ok();

}



void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused)
@@ -1904,4 +1933,28 @@ void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __ 
    ALOGW("AudioPolicyService server died!");

}



ConversionResult<record_client_info_t>

aidl2legacy_RecordClientInfo_record_client_info_t(const media::RecordClientInfo& aidl) {

    record_client_info_t legacy;

    legacy.riid = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_unique_id_t(aidl.riid));

    legacy.uid = VALUE_OR_RETURN(aidl2legacy_int32_t_uid_t(aidl.uid));

    legacy.session = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.session));

    legacy.source = VALUE_OR_RETURN(aidl2legacy_AudioSourceType_audio_source_t(aidl.source));

    legacy.port_id = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));

    legacy.silenced = aidl.silenced;

    return legacy;

}



ConversionResult<media::RecordClientInfo>

legacy2aidl_record_client_info_t_RecordClientInfo(const record_client_info_t& legacy) {

    media::RecordClientInfo aidl;

    aidl.riid = VALUE_OR_RETURN(legacy2aidl_audio_unique_id_t_int32_t(legacy.riid));

    aidl.uid = VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.uid));

    aidl.session = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(legacy.session));

    aidl.source = VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.source));

    aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(legacy.port_id));

    aidl.silenced = legacy.silenced;

    return aidl;

}



} // namespace android

media/libaudioclient/IAudioPolicyService.cpp

+3 −3
Original line number Diff line number Diff line
@@ -810,7 +810,7 @@ public: 
        return status;

    }



    virtual void registerClient(const sp<IAudioPolicyServiceClient>& client)

    virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
@@ -2304,8 +2304,8 @@ status_t BnAudioPolicyService::onTransact( 


        case REGISTER_CLIENT: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            sp<IAudioPolicyServiceClient> client = interface_cast<IAudioPolicyServiceClient>(

                    data.readStrongBinder());

            sp<media::IAudioPolicyServiceClient> client =

                    interface_cast<media::IAudioPolicyServiceClient>(data.readStrongBinder());

            registerClient(client);

            return NO_ERROR;

        } break;

media/libaudioclient/IAudioPolicyServiceClient.cpp

deleted100644 → 0
+0 −212
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "IAudioPolicyServiceClient"

#include <utils/Log.h>



#include <stdint.h>

#include <sys/types.h>



#include <binder/Parcel.h>



#include <media/IAudioPolicyServiceClient.h>

#include <media/AudioSystem.h>



namespace android {



enum {

    PORT_LIST_UPDATE = IBinder::FIRST_CALL_TRANSACTION,

    PATCH_LIST_UPDATE,

    MIX_STATE_UPDATE,

    RECORDING_CONFIGURATION_UPDATE,

    VOLUME_GROUP_CHANGED,

};



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

inline void readAudioConfigBaseFromParcel(const Parcel& data, audio_config_base_t *config) {

    config->sample_rate = data.readUint32();

    config->channel_mask = (audio_channel_mask_t) data.readInt32();

    config->format = (audio_format_t) data.readInt32();

}



inline void writeAudioConfigBaseToParcel(Parcel& data, const audio_config_base_t *config)

{

    data.writeUint32(config->sample_rate);

    data.writeInt32((int32_t) config->channel_mask);

    data.writeInt32((int32_t) config->format);

}



inline void readRecordClientInfoFromParcel(const Parcel& data, record_client_info_t *clientInfo) {

    clientInfo->riid = (audio_unique_id_t) data.readInt32();

    clientInfo->uid = (uid_t) data.readUint32();

    clientInfo->session = (audio_session_t) data.readInt32();

    clientInfo->source = (audio_source_t) data.readInt32();

    data.read(&clientInfo->port_id, sizeof(audio_port_handle_t));

    clientInfo->silenced = data.readBool();

}



inline void writeRecordClientInfoToParcel(Parcel& data, const record_client_info_t *clientInfo) {

    data.writeInt32((int32_t) clientInfo->riid);

    data.writeUint32((uint32_t) clientInfo->uid);

    data.writeInt32((int32_t) clientInfo->session);

    data.writeInt32((int32_t) clientInfo->source);

    data.write(&clientInfo->port_id, sizeof(audio_port_handle_t));

    data.writeBool(clientInfo->silenced);

}



inline void readEffectVectorFromParcel(const Parcel& data,

                                       std::vector<effect_descriptor_t> *effects) {

    int32_t numEffects = data.readInt32();

    for (int32_t i = 0; i < numEffects; i++) {

        effect_descriptor_t effect;

        if (data.read(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {

            break;

        }

        (*effects).push_back(effect);

    }

}



inline void writeEffectVectorToParcel(Parcel& data, std::vector<effect_descriptor_t> effects) {

    data.writeUint32((uint32_t) effects.size());

    for (const auto& effect : effects) {

        if (data.write(&effect, sizeof(effect_descriptor_t)) != NO_ERROR) {

            break;

        }

    }

}



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

class BpAudioPolicyServiceClient : public BpInterface<IAudioPolicyServiceClient>

{

public:

    explicit BpAudioPolicyServiceClient(const sp<IBinder>& impl)

        : BpInterface<IAudioPolicyServiceClient>(impl)

    {

    }



    void onAudioPortListUpdate()

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());

        remote()->transact(PORT_LIST_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void onAudioPatchListUpdate()

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());

        remote()->transact(PATCH_LIST_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void onAudioVolumeGroupChanged(volume_group_t group, int flags)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());

        data.writeUint32(group);

        data.writeInt32(flags);

        remote()->transact(VOLUME_GROUP_CHANGED, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());

        data.writeString8(regId);

        data.writeInt32(state);

        remote()->transact(MIX_STATE_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void onRecordingConfigurationUpdate(int event,

                                        const record_client_info_t *clientInfo,

                                        const audio_config_base_t *clientConfig,

                                        std::vector<effect_descriptor_t> clientEffects,

                                        const audio_config_base_t *deviceConfig,

                                        std::vector<effect_descriptor_t> effects,

                                        audio_patch_handle_t patchHandle,

                                        audio_source_t source) {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyServiceClient::getInterfaceDescriptor());

        data.writeInt32(event);

        writeRecordClientInfoToParcel(data, clientInfo);

        writeAudioConfigBaseToParcel(data, clientConfig);

        writeEffectVectorToParcel(data, clientEffects);

        writeAudioConfigBaseToParcel(data, deviceConfig);

        writeEffectVectorToParcel(data, effects);

        data.writeInt32(patchHandle);

        data.writeInt32((int32_t) source);

        remote()->transact(RECORDING_CONFIGURATION_UPDATE, data, &reply, IBinder::FLAG_ONEWAY);

    }

};



IMPLEMENT_META_INTERFACE(AudioPolicyServiceClient, "android.media.IAudioPolicyServiceClient");



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



status_t BnAudioPolicyServiceClient::onTransact(

    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    switch (code) {

    case PORT_LIST_UPDATE: {

            CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);

            onAudioPortListUpdate();

            return NO_ERROR;

        } break;

    case PATCH_LIST_UPDATE: {

            CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);

            onAudioPatchListUpdate();

            return NO_ERROR;

        } break;

    case VOLUME_GROUP_CHANGED: {

            CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);

            volume_group_t group = static_cast<volume_group_t>(data.readUint32());

            int flags = data.readInt32();

            onAudioVolumeGroupChanged(group, flags);

            return NO_ERROR;

        } break;

    case MIX_STATE_UPDATE: {

            CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);

            String8 regId = data.readString8();

            int32_t state = data.readInt32();

            onDynamicPolicyMixStateUpdate(regId, state);

            return NO_ERROR;

        } break;

    case RECORDING_CONFIGURATION_UPDATE: {

            CHECK_INTERFACE(IAudioPolicyServiceClient, data, reply);

            int event = (int) data.readInt32();

            record_client_info_t clientInfo;

            audio_config_base_t clientConfig;

            audio_config_base_t deviceConfig;

            readRecordClientInfoFromParcel(data, &clientInfo);

            readAudioConfigBaseFromParcel(data, &clientConfig);

            std::vector<effect_descriptor_t> clientEffects;

            readEffectVectorFromParcel(data, &clientEffects);

            readAudioConfigBaseFromParcel(data, &deviceConfig);

            std::vector<effect_descriptor_t> effects;

            readEffectVectorFromParcel(data, &effects);

            audio_patch_handle_t patchHandle = (audio_patch_handle_t) data.readInt32();

            audio_source_t source = (audio_source_t) data.readInt32();

            onRecordingConfigurationUpdate(event, &clientInfo, &clientConfig, clientEffects,

                                           &deviceConfig, effects, patchHandle, source);

            return NO_ERROR;

        } break;

    default:

        return BBinder::onTransact(code, data, reply, flags);

    }

}



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



} // namespace android