Merge "AIDLize IAudioPolicyServiceClient" (bf4b9ee0) · Commits · e / os / android_frameworks_av

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