Convert IAudioPolicyService to AIDL
Test: Audio tests from CtsMediaTests
Test: Audio smoke tests
Bug: 160253486
Change-Id: I5ecee56f71a959d2fd75714ba95d7653af0c98bc
diff --git a/media/libaudioclient/AidlConversion.cpp b/media/libaudioclient/AidlConversion.cpp
index 4f2651b..1ff4678 100644
--- a/media/libaudioclient/AidlConversion.cpp
+++ b/media/libaudioclient/AidlConversion.cpp
@@ -2117,4 +2117,14 @@
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
diff --git a/media/libaudioclient/Android.bp b/media/libaudioclient/Android.bp
index aa740a7..a1708ee 100644
--- a/media/libaudioclient/Android.bp
+++ b/media/libaudioclient/Android.bp
@@ -37,11 +37,16 @@
"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 @@
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 @@
"AudioTrack.cpp",
"AudioTrackShared.cpp",
"IAudioFlinger.cpp",
- "IAudioPolicyService.cpp",
"ToneGenerator.cpp",
"PlayerBase.cpp",
"RecordingActivityTracker.cpp",
@@ -94,8 +103,9 @@
"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 @@
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 {
+ 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 @@
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: {
diff --git a/media/libaudioclient/AudioAttributes.cpp b/media/libaudioclient/AudioAttributes.cpp
index ff4ba06..83bf5a7 100644
--- a/media/libaudioclient/AudioAttributes.cpp
+++ b/media/libaudioclient/AudioAttributes.cpp
@@ -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, "");
- }
- mStreamType = static_cast<audio_stream_type_t>(parcel->readInt32());
- mGroupId = static_cast<volume_group_t>(parcel->readUint32());
- return NO_ERROR;
+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;
}
-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));
- }
- parcel->writeInt32(static_cast<int32_t>(mStreamType));
- parcel->writeUint32(static_cast<uint32_t>(mGroupId));
- 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);
+}
+
+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;
+}
+
+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
diff --git a/media/libaudioclient/AudioEffect.cpp b/media/libaudioclient/AudioEffect.cpp
index 79ea1bb..ad8ad7b 100644
--- a/media/libaudioclient/AudioEffect.cpp
+++ b/media/libaudioclient/AudioEffect.cpp
@@ -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 @@
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 @@
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 @@
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 @@
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 @@
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));
}
// -------------------------------------------------------------------------
diff --git a/media/libaudioclient/AudioProductStrategy.cpp b/media/libaudioclient/AudioProductStrategy.cpp
index cff72fd..f98027a 100644
--- a/media/libaudioclient/AudioProductStrategy.cpp
+++ b/media/libaudioclient/AudioProductStrategy.cpp
@@ -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;
+status_t AudioProductStrategy::writeToParcel(Parcel* parcel) const {
+ media::AudioProductStrategy aidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_AudioProductStrategy(*this));
+ return aidl.writeToParcel(parcel);
+}
- 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--;
- }
- }
- if (size != finalSize) {
- size_t position = parcel->dataPosition();
- parcel->setDataPosition(sizePosition);
- parcel->writeInt32(finalSize);
- parcel->setDataPosition(position);
- }
- return NO_ERROR;
+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;
+}
+
+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
diff --git a/media/libaudioclient/AudioSystem.cpp b/media/libaudioclient/AudioSystem.cpp
index 2187635..5ce5974 100644
--- a/media/libaudioclient/AudioSystem.cpp
+++ b/media/libaudioclient/AudioSystem.cpp
@@ -19,6 +19,7 @@
#include <utils/Log.h>
+#include <android/media/IAudioPolicyService.h>
#include <android/media/BnCaptureStateListener.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
@@ -27,22 +28,30 @@
#include <media/AudioResamplerPublic.h>
#include <media/AudioSystem.h>
#include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
+#include <media/PolicyAidlConversion.h>
#include <media/TypeConverter.h>
#include <math.h>
#include <system/audio.h>
+#include <android/media/GetInputForAttrResponse.h>
#define VALUE_OR_RETURN_BINDER_STATUS(x) \
({ auto _tmp = (x); \
if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
std::move(_tmp.value()); })
+#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;
// client singleton for AudioFlinger binder interface
Mutex AudioSystem::gLock;
@@ -57,12 +66,12 @@
// Required to be held while calling into gSoundTriggerCaptureStateListener.
class CaptureStateListenerImpl;
+
Mutex gSoundTriggerCaptureStateListenerLock;
sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener = nullptr;
// establish binder interface to AudioFlinger service
-const sp<IAudioFlinger> AudioSystem::get_audio_flinger()
-{
+const sp<IAudioFlinger> AudioSystem::get_audio_flinger() {
sp<IAudioFlinger> af;
sp<AudioFlingerClient> afc;
bool reportNoError = false;
@@ -102,8 +111,7 @@
return af;
}
-const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient()
-{
+const sp<AudioSystem::AudioFlingerClient> AudioSystem::getAudioFlingerClient() {
// calling get_audio_flinger() will initialize gAudioFlingerClient if needed
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return 0;
@@ -111,8 +119,7 @@
return gAudioFlingerClient;
}
-sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor> AudioSystem::getIoDescriptor(audio_io_handle_t ioHandle) {
sp<AudioIoDescriptor> desc;
const sp<AudioFlingerClient> afc = getAudioFlingerClient();
if (afc != 0) {
@@ -121,8 +128,7 @@
return desc;
}
-/* static */ status_t AudioSystem::checkAudioFlinger()
-{
+/* static */ status_t AudioSystem::checkAudioFlinger() {
if (defaultServiceManager()->checkService(String16("media.audio_flinger")) != 0) {
return NO_ERROR;
}
@@ -131,47 +137,41 @@
// FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp
-status_t AudioSystem::muteMicrophone(bool state)
-{
+status_t AudioSystem::muteMicrophone(bool state) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setMicMute(state);
}
-status_t AudioSystem::isMicrophoneMuted(bool* state)
-{
+status_t AudioSystem::isMicrophoneMuted(bool* state) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
*state = af->getMicMute();
return NO_ERROR;
}
-status_t AudioSystem::setMasterVolume(float value)
-{
+status_t AudioSystem::setMasterVolume(float value) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
af->setMasterVolume(value);
return NO_ERROR;
}
-status_t AudioSystem::setMasterMute(bool mute)
-{
+status_t AudioSystem::setMasterMute(bool mute) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
af->setMasterMute(mute);
return NO_ERROR;
}
-status_t AudioSystem::getMasterVolume(float* volume)
-{
+status_t AudioSystem::getMasterVolume(float* volume) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
*volume = af->masterVolume();
return NO_ERROR;
}
-status_t AudioSystem::getMasterMute(bool* mute)
-{
+status_t AudioSystem::getMasterMute(bool* mute) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
*mute = af->masterMute();
@@ -179,8 +179,7 @@
}
status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
- audio_io_handle_t output)
-{
+ audio_io_handle_t output) {
if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
@@ -188,8 +187,7 @@
return NO_ERROR;
}
-status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute)
-{
+status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute) {
if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
@@ -198,8 +196,7 @@
}
status_t AudioSystem::getStreamVolume(audio_stream_type_t stream, float* volume,
- audio_io_handle_t output)
-{
+ audio_io_handle_t output) {
if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
@@ -207,8 +204,7 @@
return NO_ERROR;
}
-status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute)
-{
+status_t AudioSystem::getStreamMute(audio_stream_type_t stream, bool* mute) {
if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
@@ -216,23 +212,20 @@
return NO_ERROR;
}
-status_t AudioSystem::setMode(audio_mode_t mode)
-{
+status_t AudioSystem::setMode(audio_mode_t mode) {
if (uint32_t(mode) >= AUDIO_MODE_CNT) return BAD_VALUE;
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setMode(mode);
}
-status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
-{
+status_t AudioSystem::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setParameters(ioHandle, keyValuePairs);
}
-String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys)
-{
+String8 AudioSystem::getParameters(audio_io_handle_t ioHandle, const String8& keys) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
String8 result = String8("");
if (af == 0) return result;
@@ -241,13 +234,11 @@
return result;
}
-status_t AudioSystem::setParameters(const String8& keyValuePairs)
-{
+status_t AudioSystem::setParameters(const String8& keyValuePairs) {
return setParameters(AUDIO_IO_HANDLE_NONE, keyValuePairs);
}
-String8 AudioSystem::getParameters(const String8& keys)
-{
+String8 AudioSystem::getParameters(const String8& keys) {
return getParameters(AUDIO_IO_HANDLE_NONE, keys);
}
@@ -259,16 +250,14 @@
static const float dBConvert = -dBPerStep * 2.302585093f / 20.0f;
static const float dBConvertInverse = 1.0f / dBConvert;
-float AudioSystem::linearToLog(int volume)
-{
+float AudioSystem::linearToLog(int volume) {
// float v = volume ? exp(float(100 - volume) * dBConvert) : 0;
// ALOGD("linearToLog(%d)=%f", volume, v);
// return v;
return volume ? exp(float(100 - volume) * dBConvert) : 0;
}
-int AudioSystem::logToLinear(float volume)
-{
+int AudioSystem::logToLinear(float volume) {
// int v = volume ? 100 - int(dBConvertInverse * log(volume) + 0.5) : 0;
// ALOGD("logTolinear(%d)=%f", v, volume);
// return v;
@@ -277,31 +266,30 @@
/* static */ size_t AudioSystem::calculateMinFrameCount(
uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate,
- uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/)
-{
+ uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/) {
// Ensure that buffer depth covers at least audio hardware latency
uint32_t minBufCount = afLatencyMs / ((1000 * afFrameCount) / afSampleRate);
if (minBufCount < 2) {
minBufCount = 2;
}
#if 0
- // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
- // but keeping the code here to make it easier to add later.
- if (minBufCount < notificationsPerBufferReq) {
- minBufCount = notificationsPerBufferReq;
- }
+ // The notificationsPerBufferReq parameter is not yet used for non-fast tracks,
+ // but keeping the code here to make it easier to add later.
+ if (minBufCount < notificationsPerBufferReq) {
+ minBufCount = notificationsPerBufferReq;
+ }
#endif
ALOGV("calculateMinFrameCount afLatency %u afFrameCount %u afSampleRate %u "
- "sampleRate %u speed %f minBufCount: %u" /*" notificationsPerBufferReq %u"*/,
- afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
- /*, notificationsPerBufferReq*/);
+ "sampleRate %u speed %f minBufCount: %u" /*" notificationsPerBufferReq %u"*/,
+ afLatencyMs, afFrameCount, afSampleRate, sampleRate, speed, minBufCount
+ /*, notificationsPerBufferReq*/);
return minBufCount * sourceFramesNeededWithTimestretch(
sampleRate, afFrameCount, afSampleRate, speed);
}
-status_t AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType)
-{
+status_t
+AudioSystem::getOutputSamplingRate(uint32_t* samplingRate, audio_stream_type_t streamType) {
audio_io_handle_t output;
if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -317,8 +305,7 @@
}
status_t AudioSystem::getSamplingRate(audio_io_handle_t ioHandle,
- uint32_t* samplingRate)
-{
+ uint32_t* samplingRate) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -337,8 +324,7 @@
return NO_ERROR;
}
-status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType)
-{
+status_t AudioSystem::getOutputFrameCount(size_t* frameCount, audio_stream_type_t streamType) {
audio_io_handle_t output;
if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -354,8 +340,7 @@
}
status_t AudioSystem::getFrameCount(audio_io_handle_t ioHandle,
- size_t* frameCount)
-{
+ size_t* frameCount) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -374,8 +359,7 @@
return NO_ERROR;
}
-status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType)
-{
+status_t AudioSystem::getOutputLatency(uint32_t* latency, audio_stream_type_t streamType) {
audio_io_handle_t output;
if (streamType == AUDIO_STREAM_DEFAULT) {
@@ -391,8 +375,7 @@
}
status_t AudioSystem::getLatency(audio_io_handle_t output,
- uint32_t* latency)
-{
+ uint32_t* latency) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
sp<AudioIoDescriptor> outputDesc = getIoDescriptor(output);
@@ -408,8 +391,7 @@
}
status_t AudioSystem::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
- audio_channel_mask_t channelMask, size_t* buffSize)
-{
+ audio_channel_mask_t channelMask, size_t* buffSize) {
const sp<AudioFlingerClient> afc = getAudioFlingerClient();
if (afc == 0) {
return NO_INIT;
@@ -417,24 +399,21 @@
return afc->getInputBufferSize(sampleRate, format, channelMask, buffSize);
}
-status_t AudioSystem::setVoiceVolume(float value)
-{
+status_t AudioSystem::setVoiceVolume(float value) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setVoiceVolume(value);
}
-status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t *halFrames,
- uint32_t *dspFrames)
-{
+status_t AudioSystem::getRenderPosition(audio_io_handle_t output, uint32_t* halFrames,
+ uint32_t* dspFrames) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->getRenderPosition(halFrames, dspFrames, output);
}
-uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle)
-{
+uint32_t AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
uint32_t result = 0;
if (af == 0) return result;
@@ -444,47 +423,41 @@
return result;
}
-audio_unique_id_t AudioSystem::newAudioUniqueId(audio_unique_id_use_t use)
-{
+audio_unique_id_t AudioSystem::newAudioUniqueId(audio_unique_id_use_t use) {
// Must not use AF as IDs will re-roll on audioserver restart, b/130369529.
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return AUDIO_UNIQUE_ID_ALLOCATE;
return af->newAudioUniqueId(use);
}
-void AudioSystem::acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid)
-{
+void AudioSystem::acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af != 0) {
af->acquireAudioSessionId(audioSession, pid, uid);
}
}
-void AudioSystem::releaseAudioSessionId(audio_session_t audioSession, pid_t pid)
-{
+void AudioSystem::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af != 0) {
af->releaseAudioSessionId(audioSession, pid);
}
}
-audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId)
-{
+audio_hw_sync_t AudioSystem::getAudioHwSyncForSession(audio_session_t sessionId) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return AUDIO_HW_SYNC_INVALID;
return af->getAudioHwSyncForSession(sessionId);
}
-status_t AudioSystem::systemReady()
-{
+status_t AudioSystem::systemReady() {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return NO_INIT;
return af->systemReady();
}
status_t AudioSystem::getFrameCountHAL(audio_io_handle_t ioHandle,
- size_t* frameCount)
-{
+ size_t* frameCount) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
sp<AudioIoDescriptor> desc = getIoDescriptor(ioHandle);
@@ -506,8 +479,7 @@
// ---------------------------------------------------------------------------
-void AudioSystem::AudioFlingerClient::clearIoCache()
-{
+void AudioSystem::AudioFlingerClient::clearIoCache() {
Mutex::Autolock _l(mLock);
mIoDescriptors.clear();
mInBuffSize = 0;
@@ -516,8 +488,7 @@
mInChannelMask = AUDIO_CHANNEL_NONE;
}
-void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused)
-{
+void AudioSystem::AudioFlingerClient::binderDied(const wp<IBinder>& who __unused) {
{
Mutex::Autolock _l(AudioSystem::gLock);
AudioSystem::gAudioFlinger.clear();
@@ -537,7 +508,8 @@
audio_io_config_event event = VALUE_OR_RETURN_BINDER_STATUS(
aidl2legacy_AudioIoConfigEvent_audio_io_config_event(_event));
sp<AudioIoDescriptor> ioDesc(
- VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(_ioDesc)));
+ VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioIoDescriptor_AudioIoDescriptor(_ioDesc)));
ALOGV("ioConfigChanged() event %d", event);
@@ -550,96 +522,102 @@
auto callbacks = std::map<audio_port_handle_t, wp<AudioDeviceCallback>>();
switch (event) {
- case AUDIO_OUTPUT_OPENED:
- case AUDIO_OUTPUT_REGISTERED:
- case AUDIO_INPUT_OPENED:
- case AUDIO_INPUT_REGISTERED: {
- sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
- if (oldDesc == 0) {
- mIoDescriptors.add(ioDesc->mIoHandle, ioDesc);
- } else {
+ case AUDIO_OUTPUT_OPENED:
+ case AUDIO_OUTPUT_REGISTERED:
+ case AUDIO_INPUT_OPENED:
+ case AUDIO_INPUT_REGISTERED: {
+ sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+ if (oldDesc == 0) {
+ mIoDescriptors.add(ioDesc->mIoHandle, ioDesc);
+ } else {
+ deviceId = oldDesc->getDeviceId();
+ mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
+ }
+
+ if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) {
+ deviceId = ioDesc->getDeviceId();
+ if (event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED) {
+ auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
+ if (it != mAudioDeviceCallbacks.end()) {
+ callbacks = it->second;
+ }
+ }
+ }
+ ALOGV("ioConfigChanged() new %s %s %d samplingRate %u, format %#x channel mask %#x "
+ "frameCount %zu deviceId %d",
+ event == AUDIO_OUTPUT_OPENED || event == AUDIO_OUTPUT_REGISTERED ?
+ "output" : "input",
+ event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED ?
+ "opened" : "registered",
+ ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
+ ioDesc->mChannelMask,
+ ioDesc->mFrameCount, ioDesc->getDeviceId());
+ }
+ break;
+ case AUDIO_OUTPUT_CLOSED:
+ case AUDIO_INPUT_CLOSED: {
+ if (getIoDescriptor_l(ioDesc->mIoHandle) == 0) {
+ ALOGW("ioConfigChanged() closing unknown %s %d",
+ event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
+ break;
+ }
+ ALOGV("ioConfigChanged() %s %d closed",
+ event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
+
+ mIoDescriptors.removeItem(ioDesc->mIoHandle);
+ mAudioDeviceCallbacks.erase(ioDesc->mIoHandle);
+ }
+ break;
+
+ case AUDIO_OUTPUT_CONFIG_CHANGED:
+ case AUDIO_INPUT_CONFIG_CHANGED: {
+ sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+ if (oldDesc == 0) {
+ ALOGW("ioConfigChanged() modifying unknown %s! %d",
+ event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
+ ioDesc->mIoHandle);
+ break;
+ }
+
deviceId = oldDesc->getDeviceId();
mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
- }
- if (ioDesc->getDeviceId() != AUDIO_PORT_HANDLE_NONE) {
- deviceId = ioDesc->getDeviceId();
- if (event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED) {
+ if (deviceId != ioDesc->getDeviceId()) {
+ deviceId = ioDesc->getDeviceId();
auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
if (it != mAudioDeviceCallbacks.end()) {
callbacks = it->second;
}
}
+ ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x "
+ "channel mask %#x frameCount %zu frameCountHAL %zu deviceId %d",
+ event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
+ ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
+ ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->mFrameCountHAL,
+ ioDesc->getDeviceId());
+
}
- ALOGV("ioConfigChanged() new %s %s %d samplingRate %u, format %#x channel mask %#x "
- "frameCount %zu deviceId %d",
- event == AUDIO_OUTPUT_OPENED || event == AUDIO_OUTPUT_REGISTERED ?
- "output" : "input",
- event == AUDIO_OUTPUT_OPENED || event == AUDIO_INPUT_OPENED ?
- "opened" : "registered",
- ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat, ioDesc->mChannelMask,
- ioDesc->mFrameCount, ioDesc->getDeviceId());
- } break;
- case AUDIO_OUTPUT_CLOSED:
- case AUDIO_INPUT_CLOSED: {
- if (getIoDescriptor_l(ioDesc->mIoHandle) == 0) {
- ALOGW("ioConfigChanged() closing unknown %s %d",
- event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
break;
- }
- ALOGV("ioConfigChanged() %s %d closed",
- event == AUDIO_OUTPUT_CLOSED ? "output" : "input", ioDesc->mIoHandle);
-
- mIoDescriptors.removeItem(ioDesc->mIoHandle);
- mAudioDeviceCallbacks.erase(ioDesc->mIoHandle);
- } break;
-
- case AUDIO_OUTPUT_CONFIG_CHANGED:
- case AUDIO_INPUT_CONFIG_CHANGED: {
- sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
- if (oldDesc == 0) {
- ALOGW("ioConfigChanged() modifying unknown %s! %d",
- event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input", ioDesc->mIoHandle);
- break;
- }
-
- deviceId = oldDesc->getDeviceId();
- mIoDescriptors.replaceValueFor(ioDesc->mIoHandle, ioDesc);
-
- if (deviceId != ioDesc->getDeviceId()) {
- deviceId = ioDesc->getDeviceId();
+ case AUDIO_CLIENT_STARTED: {
+ sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
+ if (oldDesc == 0) {
+ ALOGW("ioConfigChanged() start client on unknown io! %d", ioDesc->mIoHandle);
+ break;
+ }
+ ALOGV("ioConfigChanged() AUDIO_CLIENT_STARTED io %d port %d num callbacks %zu",
+ ioDesc->mIoHandle, ioDesc->mPortId, mAudioDeviceCallbacks.size());
+ oldDesc->mPatch = ioDesc->mPatch;
auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
if (it != mAudioDeviceCallbacks.end()) {
- callbacks = it->second;
+ auto cbks = it->second;
+ auto it2 = cbks.find(ioDesc->mPortId);
+ if (it2 != cbks.end()) {
+ callbacks.emplace(ioDesc->mPortId, it2->second);
+ deviceId = oldDesc->getDeviceId();
+ }
}
}
- ALOGV("ioConfigChanged() new config for %s %d samplingRate %u, format %#x "
- "channel mask %#x frameCount %zu frameCountHAL %zu deviceId %d",
- event == AUDIO_OUTPUT_CONFIG_CHANGED ? "output" : "input",
- ioDesc->mIoHandle, ioDesc->mSamplingRate, ioDesc->mFormat,
- ioDesc->mChannelMask, ioDesc->mFrameCount, ioDesc->mFrameCountHAL,
- ioDesc->getDeviceId());
-
- } break;
- case AUDIO_CLIENT_STARTED: {
- sp<AudioIoDescriptor> oldDesc = getIoDescriptor_l(ioDesc->mIoHandle);
- if (oldDesc == 0) {
- ALOGW("ioConfigChanged() start client on unknown io! %d", ioDesc->mIoHandle);
break;
- }
- ALOGV("ioConfigChanged() AUDIO_CLIENT_STARTED io %d port %d num callbacks %zu",
- ioDesc->mIoHandle, ioDesc->mPortId, mAudioDeviceCallbacks.size());
- oldDesc->mPatch = ioDesc->mPatch;
- auto it = mAudioDeviceCallbacks.find(ioDesc->mIoHandle);
- if (it != mAudioDeviceCallbacks.end()) {
- auto cbks = it->second;
- auto it2 = cbks.find(ioDesc->mPortId);
- if (it2 != cbks.end()) {
- callbacks.emplace(ioDesc->mPortId, it2->second);
- deviceId = oldDesc->getDeviceId();
- }
- }
- } break;
}
for (auto wpCbk : callbacks) {
@@ -661,9 +639,8 @@
}
status_t AudioSystem::AudioFlingerClient::getInputBufferSize(
- uint32_t sampleRate, audio_format_t format,
- audio_channel_mask_t channelMask, size_t* buffSize)
-{
+ uint32_t sampleRate, audio_format_t format,
+ audio_channel_mask_t channelMask, size_t* buffSize) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) {
return PERMISSION_DENIED;
@@ -675,7 +652,7 @@
size_t inBuffSize = af->getInputBufferSize(sampleRate, format, channelMask);
if (inBuffSize == 0) {
ALOGE("AudioSystem::getInputBufferSize failed sampleRate %d format %#x channelMask %#x",
- sampleRate, format, channelMask);
+ sampleRate, format, channelMask);
return BAD_VALUE;
}
// A benign race is possible here: we could overwrite a fresher cache entry
@@ -692,8 +669,8 @@
return NO_ERROR;
}
-sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor>
+AudioSystem::AudioFlingerClient::getIoDescriptor_l(audio_io_handle_t ioHandle) {
sp<AudioIoDescriptor> desc;
ssize_t index = mIoDescriptors.indexOfKey(ioHandle);
if (index >= 0) {
@@ -702,19 +679,19 @@
return desc;
}
-sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle)
-{
+sp<AudioIoDescriptor> AudioSystem::AudioFlingerClient::getIoDescriptor(audio_io_handle_t ioHandle) {
Mutex::Autolock _l(mLock);
return getIoDescriptor_l(ioHandle);
}
status_t AudioSystem::AudioFlingerClient::addAudioDeviceCallback(
const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
- audio_port_handle_t portId)
-{
+ audio_port_handle_t portId) {
ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
Mutex::Autolock _l(mLock);
- auto& callbacks = mAudioDeviceCallbacks.emplace(audioIo, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
+ auto& callbacks = mAudioDeviceCallbacks.emplace(
+ audioIo,
+ std::map<audio_port_handle_t, wp<AudioDeviceCallback>>()).first->second;
auto result = callbacks.try_emplace(portId, callback);
if (!result.second) {
return INVALID_OPERATION;
@@ -724,8 +701,7 @@
status_t AudioSystem::AudioFlingerClient::removeAudioDeviceCallback(
const wp<AudioDeviceCallback>& callback __unused, audio_io_handle_t audioIo,
- audio_port_handle_t portId)
-{
+ audio_port_handle_t portId) {
ALOGV("%s audioIo %d portId %d", __func__, audioIo, portId);
Mutex::Autolock _l(mLock);
auto it = mAudioDeviceCallbacks.find(audioIo);
@@ -741,8 +717,7 @@
return NO_ERROR;
}
-/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb)
-{
+/* static */ uintptr_t AudioSystem::addErrorCallback(audio_error_callback cb) {
Mutex::Autolock _l(gLockErrorCallbacks);
gAudioErrorCallbacks.insert(cb);
return reinterpret_cast<uintptr_t>(cb);
@@ -756,24 +731,21 @@
/* static */ void AudioSystem::reportError(status_t err) {
Mutex::Autolock _l(gLockErrorCallbacks);
for (auto callback : gAudioErrorCallbacks) {
- callback(err);
+ callback(err);
}
}
-/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb)
-{
+/*static*/ void AudioSystem::setDynPolicyCallback(dynamic_policy_callback cb) {
Mutex::Autolock _l(gLock);
gDynPolicyCallback = cb;
}
-/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb)
-{
+/*static*/ void AudioSystem::setRecordConfigCallback(record_config_callback cb) {
Mutex::Autolock _l(gLock);
gRecordConfigCallback = cb;
}
-/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb)
-{
+/*static*/ void AudioSystem::setRoutingCallback(routing_callback cb) {
Mutex::Autolock _l(gLock);
gRoutingCallback = cb;
}
@@ -785,8 +757,7 @@
// establish binder interface to AudioPolicy service
-const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service()
-{
+const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() {
sp<IAudioPolicyService> ap;
sp<AudioPolicyServiceClient> apc;
{
@@ -826,8 +797,7 @@
// ---------------------------------------------------------------------------
-void AudioSystem::onNewAudioModulesAvailable()
-{
+void AudioSystem::onNewAudioModulesAvailable() {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return;
aps->onNewAudioModulesAvailable();
@@ -835,13 +805,12 @@
status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,
audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
-{
+ const char* device_address,
+ const char* device_name,
+ audio_format_t encodedFormat) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
- const char *address = "";
- const char *name = "";
+ const char* address = "";
+ const char* name = "";
if (aps == 0) return PERMISSION_DENIED;
@@ -851,26 +820,46 @@
if (device_name != NULL) {
name = device_name;
}
- return aps->setDeviceConnectionState(device, state, address, name, encodedFormat);
+
+ media::AudioDevice deviceAidl;
+ deviceAidl.type = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ deviceAidl.address = address;
+
+ return statusTFromBinderStatus(
+ aps->setDeviceConnectionState(
+ deviceAidl,
+ VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(state)),
+ name,
+ VALUE_OR_RETURN_STATUS(legacy2aidl_audio_format_t_AudioFormat(encodedFormat))));
}
audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device,
- const char *device_address)
-{
+ const char* device_address) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
- return aps->getDeviceConnectionState(device, device_address);
+ auto result = [&]() -> ConversionResult<audio_policy_dev_state_t> {
+ media::AudioDevice deviceAidl;
+ deviceAidl.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(device));
+ deviceAidl.address = device_address;
+
+ media::AudioPolicyDeviceState result;
+ RETURN_IF_ERROR(statusTFromBinderStatus(
+ aps->getDeviceConnectionState(deviceAidl, &result)));
+
+ return aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(result);
+ }();
+ return result.value_or(AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE);
}
status_t AudioSystem::handleDeviceConfigChange(audio_devices_t device,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
-{
+ const char* device_address,
+ const char* device_name,
+ audio_format_t encodedFormat) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
- const char *address = "";
- const char *name = "";
+ const char* address = "";
+ const char* name = "";
if (aps == 0) return PERMISSION_DENIED;
@@ -880,294 +869,533 @@
if (device_name != NULL) {
name = device_name;
}
- return aps->handleDeviceConfigChange(device, address, name, encodedFormat);
+
+ media::AudioDevice deviceAidl;
+ deviceAidl.type = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ deviceAidl.address = address;
+
+ return statusTFromBinderStatus(
+ aps->handleDeviceConfigChange(deviceAidl, name, VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_format_t_AudioFormat(encodedFormat))));
}
-status_t AudioSystem::setPhoneState(audio_mode_t state, uid_t uid)
-{
+status_t AudioSystem::setPhoneState(audio_mode_t state, uid_t uid) {
if (uint32_t(state) >= AUDIO_MODE_CNT) return BAD_VALUE;
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setPhoneState(state, uid);
+ return statusTFromBinderStatus(aps->setPhoneState(
+ VALUE_OR_RETURN_STATUS(legacy2aidl_audio_mode_t_AudioMode(state)),
+ VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid))));
}
-status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
-{
+status_t
+AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setForceUse(usage, config);
+
+ return statusTFromBinderStatus(
+ aps->setForceUse(
+ VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage)),
+ VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
+ config))));
}
-audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage)
-{
+audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return AUDIO_POLICY_FORCE_NONE;
- return aps->getForceUse(usage);
+
+ auto result = [&]() -> ConversionResult<audio_policy_forced_cfg_t> {
+ media::AudioPolicyForceUse usageAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(usage));
+ media::AudioPolicyForcedConfig configAidl;
+ RETURN_IF_ERROR(statusTFromBinderStatus(
+ aps->getForceUse(usageAidl, &configAidl)));
+ return aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl);
+ }();
+
+ return result.value_or(AUDIO_POLICY_FORCE_NONE);
}
-audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream)
-{
+audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
- if (aps == 0) return 0;
- return aps->getOutput(stream);
+ if (aps == 0) return AUDIO_IO_HANDLE_NONE;
+
+ auto result = [&]() -> ConversionResult<audio_io_handle_t> {
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t outputAidl;
+ RETURN_IF_ERROR(
+ statusTFromBinderStatus(aps->getOutput(streamAidl, &outputAidl)));
+ return aidl2legacy_int32_t_audio_io_handle_t(outputAidl);
+ }();
+
+ return result.value_or(AUDIO_IO_HANDLE_NONE);
}
-status_t AudioSystem::getOutputForAttr(audio_attributes_t *attr,
- audio_io_handle_t *output,
- audio_session_t session,
- audio_stream_type_t *stream,
- pid_t pid,
- uid_t uid,
- const audio_config_t *config,
- audio_output_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId,
- std::vector<audio_io_handle_t> *secondaryOutputs)
-{
+status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr,
+ audio_io_handle_t* output,
+ audio_session_t session,
+ audio_stream_type_t* stream,
+ pid_t pid,
+ uid_t uid,
+ const audio_config_t* config,
+ audio_output_flags_t flags,
+ audio_port_handle_t* selectedDeviceId,
+ audio_port_handle_t* portId,
+ std::vector<audio_io_handle_t>* secondaryOutputs) {
+ if (attr == nullptr) {
+ ALOGE("%s NULL audio attributes", __func__);
+ return BAD_VALUE;
+ }
+ if (output == nullptr) {
+ ALOGE("%s NULL output - shouldn't happen", __func__);
+ return BAD_VALUE;
+ }
+ if (selectedDeviceId == nullptr) {
+ ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__);
+ return BAD_VALUE;
+ }
+ if (portId == nullptr) {
+ ALOGE("%s NULL portId - shouldn't happen", __func__);
+ return BAD_VALUE;
+ }
+ if (secondaryOutputs == nullptr) {
+ ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return NO_INIT;
- return aps->getOutputForAttr(attr, output, session, stream, pid, uid,
- config,
- flags, selectedDeviceId, portId, secondaryOutputs);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));
+ int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+ int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ media::AudioConfig configAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_config_t_AudioConfig(*config));
+ int32_t flagsAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
+
+ media::GetOutputForAttrResponse responseAidl;
+
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getOutputForAttr(attrAidl, sessionAidl, pidAidl, uidAidl, configAidl, flagsAidl,
+ &responseAidl)));
+
+ *output = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_int32_t_audio_io_handle_t(responseAidl.output));
+
+ if (stream != nullptr) {
+ *stream = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(responseAidl.stream));
+ }
+ *selectedDeviceId = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(responseAidl.selectedDeviceId));
+ *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(responseAidl.portId));
+ *secondaryOutputs = VALUE_OR_RETURN_STATUS(convertContainer<std::vector<audio_io_handle_t>>(
+ responseAidl.secondaryOutputs, aidl2legacy_int32_t_audio_io_handle_t));
+
+ return OK;
}
-status_t AudioSystem::startOutput(audio_port_handle_t portId)
-{
+status_t AudioSystem::startOutput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->startOutput(portId);
+
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return statusTFromBinderStatus(aps->startOutput(portIdAidl));
}
-status_t AudioSystem::stopOutput(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopOutput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->stopOutput(portId);
+
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return statusTFromBinderStatus(aps->stopOutput(portIdAidl));
}
-void AudioSystem::releaseOutput(audio_port_handle_t portId)
-{
+void AudioSystem::releaseOutput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return;
- aps->releaseOutput(portId);
+
+ auto status = [&]() -> status_t {
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(portId));
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseOutput(portIdAidl)));
+ return OK;
+ }();
+
+ // Ignore status.
+ (void) status;
}
-status_t AudioSystem::getInputForAttr(const audio_attributes_t *attr,
- audio_io_handle_t *input,
- audio_unique_id_t riid,
- audio_session_t session,
- pid_t pid,
- uid_t uid,
- const String16& opPackageName,
- const audio_config_base_t *config,
- audio_input_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId)
-{
+status_t AudioSystem::getInputForAttr(const audio_attributes_t* attr,
+ audio_io_handle_t* input,
+ audio_unique_id_t riid,
+ audio_session_t session,
+ pid_t pid,
+ uid_t uid,
+ const String16& opPackageName,
+ const audio_config_base_t* config,
+ audio_input_flags_t flags,
+ audio_port_handle_t* selectedDeviceId,
+ audio_port_handle_t* portId) {
+ if (attr == NULL) {
+ ALOGE("getInputForAttr NULL attr - shouldn't happen");
+ return BAD_VALUE;
+ }
+ if (input == NULL) {
+ ALOGE("getInputForAttr NULL input - shouldn't happen");
+ return BAD_VALUE;
+ }
+ if (selectedDeviceId == NULL) {
+ ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
+ return BAD_VALUE;
+ }
+ if (portId == NULL) {
+ ALOGE("getInputForAttr NULL portId - shouldn't happen");
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return NO_INIT;
- return aps->getInputForAttr(
- attr, input, riid, session, pid, uid, opPackageName,
- config, flags, selectedDeviceId, portId);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attr));
+ int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(*input));
+ int32_t riidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_unique_id_t_int32_t(riid));
+ int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+ int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ std::string opPackageNameAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_String16_string(opPackageName));
+ media::AudioConfigBase configAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_config_base_t_AudioConfigBase(*config));
+ int32_t flagsAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
+
+ media::GetInputForAttrResponse response;
+
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getInputForAttr(attrAidl, inputAidl, riidAidl, sessionAidl, pidAidl, uidAidl,
+ opPackageNameAidl, configAidl, flagsAidl, &response)));
+
+ *input = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(response.input));
+ *selectedDeviceId = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(response.selectedDeviceId));
+ *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(response.portId));
+
+ return OK;
}
-status_t AudioSystem::startInput(audio_port_handle_t portId)
-{
+status_t AudioSystem::startInput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->startInput(portId);
+
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return statusTFromBinderStatus(aps->startInput(portIdAidl));
}
-status_t AudioSystem::stopInput(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopInput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->stopInput(portId);
+
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return statusTFromBinderStatus(aps->stopInput(portIdAidl));
}
-void AudioSystem::releaseInput(audio_port_handle_t portId)
-{
+void AudioSystem::releaseInput(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return;
- aps->releaseInput(portId);
+
+ auto status = [&]() -> status_t {
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(portId));
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aps->releaseInput(portIdAidl)));
+ return OK;
+ }();
+
+ // Ignore status.
+ (void) status;
}
status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,
- int indexMin,
- int indexMax)
-{
+ int indexMin,
+ int indexMax) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->initStreamVolume(stream, indexMin, indexMax);
+
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t indexMinAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMin));
+ int32_t indexMaxAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(indexMax));
+ return statusTFromBinderStatus(
+ aps->initStreamVolume(streamAidl, indexMinAidl, indexMaxAidl));
}
status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
int index,
- audio_devices_t device)
-{
+ audio_devices_t device) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setStreamVolumeIndex(stream, index, device);
+
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
+ int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ return statusTFromBinderStatus(
+ aps->setStreamVolumeIndex(streamAidl, deviceAidl, indexAidl));
}
status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
- int *index,
- audio_devices_t device)
-{
+ int* index,
+ audio_devices_t device) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getStreamVolumeIndex(stream, index, device);
+
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ int32_t indexAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getStreamVolumeIndex(streamAidl, deviceAidl, &indexAidl)));
+ if (index != nullptr) {
+ *index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+ }
+ return OK;
}
-status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t &attr,
+status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t& attr,
int index,
- audio_devices_t device)
-{
+ audio_devices_t device) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setVolumeIndexForAttributes(attr, index, device);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+ int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
+ int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ return statusTFromBinderStatus(
+ aps->setVolumeIndexForAttributes(attrAidl, deviceAidl, indexAidl));
}
-status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t &attr,
- int &index,
- audio_devices_t device)
-{
+status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t& attr,
+ int& index,
+ audio_devices_t device) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getVolumeIndexForAttributes(attr, index, device);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+ int32_t deviceAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_devices_t_int32_t(device));
+ int32_t indexAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getVolumeIndexForAttributes(attrAidl, deviceAidl, &indexAidl)));
+ index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+ return OK;
}
-status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-{
+status_t AudioSystem::getMaxVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getMaxVolumeIndexForAttributes(attr, index);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+ int32_t indexAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getMaxVolumeIndexForAttributes(attrAidl, &indexAidl)));
+ index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+ return OK;
}
-status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
-{
+status_t AudioSystem::getMinVolumeIndexForAttributes(const audio_attributes_t& attr, int& index) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getMinVolumeIndexForAttributes(attr, index);
+
+ media::AudioAttributesInternal attrAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
+ int32_t indexAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getMinVolumeIndexForAttributes(attrAidl, &indexAidl)));
+ index = VALUE_OR_RETURN_STATUS(convertIntegral<int>(indexAidl));
+ return OK;
}
-uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream)
-{
+product_strategy_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PRODUCT_STRATEGY_NONE;
- return aps->getStrategyForStream(stream);
+
+ auto result = [&]() -> ConversionResult<product_strategy_t> {
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t resultAidl;
+ RETURN_IF_ERROR(statusTFromBinderStatus(
+ aps->getStrategyForStream(streamAidl, &resultAidl)));
+ return aidl2legacy_int32_t_product_strategy_t(resultAidl);
+ }();
+ return result.value_or(PRODUCT_STRATEGY_NONE);
}
-audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream)
-{
+audio_devices_t AudioSystem::getDevicesForStream(audio_stream_type_t stream) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return AUDIO_DEVICE_NONE;
- return aps->getDevicesForStream(stream);
+
+ auto result = [&]() -> ConversionResult<audio_devices_t> {
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t resultAidl;
+ RETURN_IF_ERROR(statusTFromBinderStatus(
+ aps->getDevicesForStream(streamAidl, &resultAidl)));
+ return aidl2legacy_int32_t_audio_devices_t(resultAidl);
+ }();
+ return result.value_or(AUDIO_DEVICE_NONE);
}
-status_t AudioSystem::getDevicesForAttributes(const AudioAttributes &aa,
- AudioDeviceTypeAddrVector *devices) {
+status_t AudioSystem::getDevicesForAttributes(const AudioAttributes& aa,
+ AudioDeviceTypeAddrVector* devices) {
if (devices == nullptr) {
return BAD_VALUE;
}
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getDevicesForAttributes(aa, devices);
+
+ media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+ std::vector<media::AudioDevice> retAidl;
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(aps->getDevicesForAttributes(aaAidl, &retAidl)));
+ *devices = VALUE_OR_RETURN_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(
+ retAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+ return OK;
}
-audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t *desc)
-{
+audio_io_handle_t AudioSystem::getOutputForEffect(const effect_descriptor_t* desc) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
// FIXME change return type to status_t, and return PERMISSION_DENIED here
if (aps == 0) return AUDIO_IO_HANDLE_NONE;
- return aps->getOutputForEffect(desc);
+
+ auto result = [&]() -> ConversionResult<audio_io_handle_t> {
+ media::EffectDescriptor descAidl = VALUE_OR_RETURN(
+ legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
+ int32_t retAidl;
+ RETURN_IF_ERROR(
+ statusTFromBinderStatus(aps->getOutputForEffect(descAidl, &retAidl)));
+ return aidl2legacy_int32_t_audio_io_handle_t(retAidl);
+ }();
+
+ return result.value_or(AUDIO_IO_HANDLE_NONE);
}
-status_t AudioSystem::registerEffect(const effect_descriptor_t *desc,
- audio_io_handle_t io,
- uint32_t strategy,
- audio_session_t session,
- int id)
-{
+status_t AudioSystem::registerEffect(const effect_descriptor_t* desc,
+ audio_io_handle_t io,
+ product_strategy_t strategy,
+ audio_session_t session,
+ int id) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->registerEffect(desc, io, strategy, session, id);
+
+ media::EffectDescriptor descAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_effect_descriptor_t_EffectDescriptor(*desc));
+ int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
+ int32_t strategyAidl = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_product_strategy_t(strategy));
+ int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+ int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+ return statusTFromBinderStatus(
+ aps->registerEffect(descAidl, ioAidl, strategyAidl, sessionAidl, idAidl));
}
-status_t AudioSystem::unregisterEffect(int id)
-{
+status_t AudioSystem::unregisterEffect(int id) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->unregisterEffect(id);
+
+ int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+ return statusTFromBinderStatus(
+ aps->unregisterEffect(idAidl));
}
-status_t AudioSystem::setEffectEnabled(int id, bool enabled)
-{
+status_t AudioSystem::setEffectEnabled(int id, bool enabled) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setEffectEnabled(id, enabled);
+
+ int32_t idAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(id));
+ return statusTFromBinderStatus(
+ aps->setEffectEnabled(idAidl, enabled));
}
-status_t AudioSystem::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
-{
+status_t AudioSystem::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->moveEffectsToIo(ids, io);
+
+ std::vector<int32_t> idsAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<int32_t>>(ids, convertReinterpret<int32_t, int>));
+ int32_t ioAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(io));
+ return statusTFromBinderStatus(aps->moveEffectsToIo(idsAidl, ioAidl));
}
-status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs)
-{
+status_t AudioSystem::isStreamActive(audio_stream_type_t stream, bool* state, uint32_t inPastMs) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
if (state == NULL) return BAD_VALUE;
- *state = aps->isStreamActive(stream, inPastMs);
- return NO_ERROR;
+
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->isStreamActive(streamAidl, inPastMsAidl, state)));
+ return OK;
}
status_t AudioSystem::isStreamActiveRemotely(audio_stream_type_t stream, bool* state,
- uint32_t inPastMs)
-{
+ uint32_t inPastMs) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
if (state == NULL) return BAD_VALUE;
- *state = aps->isStreamActiveRemotely(stream, inPastMs);
- return NO_ERROR;
+
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t inPastMsAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(inPastMs));
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->isStreamActiveRemotely(streamAidl, inPastMsAidl, state)));
+ return OK;
}
-status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state)
-{
+status_t AudioSystem::isSourceActive(audio_source_t stream, bool* state) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
if (state == NULL) return BAD_VALUE;
- *state = aps->isSourceActive(stream);
- return NO_ERROR;
+
+ media::AudioSourceType streamAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(stream));
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->isSourceActive(streamAidl, state)));
+ return OK;
}
-uint32_t AudioSystem::getPrimaryOutputSamplingRate()
-{
+uint32_t AudioSystem::getPrimaryOutputSamplingRate() {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return 0;
return af->getPrimaryOutputSamplingRate();
}
-size_t AudioSystem::getPrimaryOutputFrameCount()
-{
+size_t AudioSystem::getPrimaryOutputFrameCount() {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return 0;
return af->getPrimaryOutputFrameCount();
}
-status_t AudioSystem::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory)
-{
+status_t AudioSystem::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setLowRamDevice(isLowRamDevice, totalMemory);
}
-void AudioSystem::clearAudioConfigCache()
-{
+void AudioSystem::clearAudioConfigCache() {
// called by restoreTrack_l(), which needs new IAudioFlinger and IAudioPolicyService instances
ALOGV("clearAudioConfigCache()");
{
@@ -1186,74 +1414,152 @@
status_t AudioSystem::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == nullptr) return PERMISSION_DENIED;
- return aps->setSupportedSystemUsages(systemUsages);
+
+ std::vector<media::AudioUsage> systemUsagesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioUsage>>(systemUsages,
+ legacy2aidl_audio_usage_t_AudioUsage));
+ return statusTFromBinderStatus(aps->setSupportedSystemUsages(systemUsagesAidl));
}
-status_t AudioSystem::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) {
+status_t AudioSystem::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == nullptr) return PERMISSION_DENIED;
- return aps->setAllowedCapturePolicy(uid, flags);
+
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ int32_t capturePolicyAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_flags_mask_t_int32_t_mask(capturePolicy));
+ return statusTFromBinderStatus(aps->setAllowedCapturePolicy(uidAidl, capturePolicyAidl));
}
-audio_offload_mode_t AudioSystem::getOffloadSupport(const audio_offload_info_t& info)
-{
+audio_offload_mode_t AudioSystem::getOffloadSupport(const audio_offload_info_t& info) {
ALOGV("%s", __func__);
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return AUDIO_OFFLOAD_NOT_SUPPORTED;
- return aps->getOffloadSupport(info);
+
+ auto result = [&]() -> ConversionResult<audio_offload_mode_t> {
+ media::AudioOffloadInfo infoAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_offload_info_t_AudioOffloadInfo(info));
+ media::AudioOffloadMode retAidl;
+ RETURN_IF_ERROR(
+ statusTFromBinderStatus(aps->getOffloadSupport(infoAidl, &retAidl)));
+ return aidl2legacy_AudioOffloadMode_audio_offload_mode_t(retAidl);
+ }();
+
+ return result.value_or(static_cast<audio_offload_mode_t>(0));
}
status_t AudioSystem::listAudioPorts(audio_port_role_t role,
audio_port_type_t type,
- unsigned int *num_ports,
- struct audio_port_v7 *ports,
- unsigned int *generation)
-{
+ unsigned int* num_ports,
+ struct audio_port_v7* ports,
+ unsigned int* generation) {
+ if (num_ports == nullptr || (*num_ports != 0 && ports == nullptr) ||
+ generation == nullptr) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->listAudioPorts(role, type, num_ports, ports, generation);
+
+ media::AudioPortRole roleAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_role_t_AudioPortRole(role));
+ media::AudioPortType typeAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_type_t_AudioPortType(type));
+ media::Int numPortsAidl;
+ numPortsAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_ports));
+ std::vector<media::AudioPort> portsAidl;
+ int32_t generationAidl;
+
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->listAudioPorts(roleAidl, typeAidl, &numPortsAidl, &portsAidl, &generationAidl)));
+ *num_ports = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPortsAidl.value));
+ *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
+ RETURN_STATUS_IF_ERROR(convertRange(portsAidl.begin(), portsAidl.end(), ports,
+ aidl2legacy_AudioPort_audio_port_v7));
+ return OK;
}
-status_t AudioSystem::getAudioPort(struct audio_port_v7 *port)
-{
+status_t AudioSystem::getAudioPort(struct audio_port_v7* port) {
+ if (port == nullptr) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getAudioPort(port);
+
+ media::AudioPort portAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_v7_AudioPort(*port));
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(aps->getAudioPort(portAidl, &portAidl)));
+ *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPort_audio_port_v7(portAidl));
+ return OK;
}
-status_t AudioSystem::createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle)
-{
+status_t AudioSystem::createAudioPatch(const struct audio_patch* patch,
+ audio_patch_handle_t* handle) {
+ if (patch == nullptr || handle == nullptr) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->createAudioPatch(patch, handle);
+
+ media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_patch_AudioPatch(*patch));
+ int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(aps->createAudioPatch(patchAidl, handleAidl, &handleAidl)));
+ *handle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
+ return OK;
}
-status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle)
-{
+status_t AudioSystem::releaseAudioPatch(audio_patch_handle_t handle) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->releaseAudioPatch(handle);
+
+ int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
+ return statusTFromBinderStatus(aps->releaseAudioPatch(handleAidl));
}
-status_t AudioSystem::listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches,
- unsigned int *generation)
-{
+status_t AudioSystem::listAudioPatches(unsigned int* num_patches,
+ struct audio_patch* patches,
+ unsigned int* generation) {
+ if (num_patches == nullptr || (*num_patches != 0 && patches == nullptr) ||
+ generation == nullptr) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->listAudioPatches(num_patches, patches, generation);
+
+
+ media::Int numPatchesAidl;
+ numPatchesAidl.value = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
+ std::vector<media::AudioPatch> patchesAidl;
+ int32_t generationAidl;
+
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->listAudioPatches(&numPatchesAidl, &patchesAidl, &generationAidl)));
+ *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(numPatchesAidl.value));
+ *generation = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(generationAidl));
+ RETURN_STATUS_IF_ERROR(convertRange(patchesAidl.begin(), patchesAidl.end(), patches,
+ aidl2legacy_AudioPatch_audio_patch));
+ return OK;
}
-status_t AudioSystem::setAudioPortConfig(const struct audio_port_config *config)
-{
+status_t AudioSystem::setAudioPortConfig(const struct audio_port_config* config) {
+ if (config == nullptr) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setAudioPortConfig(config);
+
+ media::AudioPortConfig configAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_config_AudioPortConfig(*config));
+ return statusTFromBinderStatus(aps->setAudioPortConfig(configAidl));
}
-status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback)
-{
+status_t AudioSystem::addAudioPortCallback(const sp<AudioPortCallback>& callback) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
@@ -1269,8 +1575,7 @@
}
/*static*/
-status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback)
-{
+status_t AudioSystem::removeAudioPortCallback(const sp<AudioPortCallback>& callback) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
@@ -1285,8 +1590,7 @@
return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
}
-status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
-{
+status_t AudioSystem::addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
@@ -1301,8 +1605,7 @@
return (ret < 0) ? INVALID_OPERATION : NO_ERROR;
}
-status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback)
-{
+status_t AudioSystem::removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
@@ -1319,8 +1622,7 @@
status_t AudioSystem::addAudioDeviceCallback(
const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
- audio_port_handle_t portId)
-{
+ audio_port_handle_t portId) {
const sp<AudioFlingerClient> afc = getAudioFlingerClient();
if (afc == 0) {
return NO_INIT;
@@ -1337,8 +1639,7 @@
status_t AudioSystem::removeAudioDeviceCallback(
const wp<AudioDeviceCallback>& callback, audio_io_handle_t audioIo,
- audio_port_handle_t portId)
-{
+ audio_port_handle_t portId) {
const sp<AudioFlingerClient> afc = getAudioFlingerClient();
if (afc == 0) {
return NO_INIT;
@@ -1346,8 +1647,7 @@
return afc->removeAudioDeviceCallback(callback, audioIo, portId);
}
-audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo)
-{
+audio_port_handle_t AudioSystem::getDeviceIdForIo(audio_io_handle_t audioIo) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
const sp<AudioIoDescriptor> desc = getIoDescriptor(audioIo);
@@ -1357,224 +1657,321 @@
return desc->getDeviceId();
}
-status_t AudioSystem::acquireSoundTriggerSession(audio_session_t *session,
- audio_io_handle_t *ioHandle,
- audio_devices_t *device)
-{
+status_t AudioSystem::acquireSoundTriggerSession(audio_session_t* session,
+ audio_io_handle_t* ioHandle,
+ audio_devices_t* device) {
+ if (session == nullptr || ioHandle == nullptr || device == nullptr) {
+ return BAD_VALUE;
+ }
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->acquireSoundTriggerSession(session, ioHandle, device);
+
+ media::SoundTriggerSession retAidl;
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(aps->acquireSoundTriggerSession(&retAidl)));
+ *session = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_session_t(retAidl.session));
+ *ioHandle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_io_handle_t(retAidl.ioHandle));
+ *device = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_devices_t(retAidl.device));
+ return OK;
}
-status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session)
-{
+status_t AudioSystem::releaseSoundTriggerSession(audio_session_t session) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->releaseSoundTriggerSession(session);
+
+ int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
+ return statusTFromBinderStatus(aps->releaseSoundTriggerSession(sessionAidl));
}
-audio_mode_t AudioSystem::getPhoneState()
-{
+audio_mode_t AudioSystem::getPhoneState() {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return AUDIO_MODE_INVALID;
- return aps->getPhoneState();
+
+ auto result = [&]() -> ConversionResult<audio_mode_t> {
+ media::AudioMode retAidl;
+ RETURN_IF_ERROR(statusTFromBinderStatus(aps->getPhoneState(&retAidl)));
+ return aidl2legacy_AudioMode_audio_mode_t(retAidl);
+ }();
+
+ return result.value_or(AUDIO_MODE_INVALID);
}
-status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
-{
+status_t AudioSystem::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->registerPolicyMixes(mixes, registration);
+
+ size_t mixesSize = std::min(mixes.size(), size_t{MAX_MIXES_PER_POLICY});
+ std::vector<media::AudioMix> mixesAidl;
+ RETURN_STATUS_IF_ERROR(
+ convertRange(mixes.begin(), mixes.begin() + mixesSize, std::back_inserter(mixesAidl),
+ legacy2aidl_AudioMix));
+ return statusTFromBinderStatus(aps->registerPolicyMixes(mixesAidl, registration));
}
-status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
-{
+status_t AudioSystem::setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setUidDeviceAffinities(uid, devices);
+
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(aps->setUidDeviceAffinities(uidAidl, devicesAidl));
}
status_t AudioSystem::removeUidDeviceAffinities(uid_t uid) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->removeUidDeviceAffinities(uid);
+
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ return statusTFromBinderStatus(aps->removeUidDeviceAffinities(uidAidl));
}
status_t AudioSystem::setUserIdDeviceAffinities(int userId,
- const AudioDeviceTypeAddrVector& devices)
-{
+ const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setUserIdDeviceAffinities(userId, devices);
+
+ int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(
+ aps->setUserIdDeviceAffinities(userIdAidl, devicesAidl));
}
-status_t AudioSystem::removeUserIdDeviceAffinities(int userId)
-{
+status_t AudioSystem::removeUserIdDeviceAffinities(int userId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->removeUserIdDeviceAffinities(userId);
+ int32_t userIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(userId));
+ return statusTFromBinderStatus(aps->removeUserIdDeviceAffinities(userIdAidl));
}
-status_t AudioSystem::startAudioSource(const struct audio_port_config *source,
- const audio_attributes_t *attributes,
- audio_port_handle_t *portId)
-{
+status_t AudioSystem::startAudioSource(const struct audio_port_config* source,
+ const audio_attributes_t* attributes,
+ audio_port_handle_t* portId) {
+ if (source == nullptr || attributes == nullptr || portId == nullptr) {
+ return BAD_VALUE;
+ }
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->startAudioSource(source, attributes, portId);
+
+ media::AudioPortConfig sourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_port_config_AudioPortConfig(*source));
+ media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(*attributes));
+ int32_t portIdAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->startAudioSource(sourceAidl, attributesAidl, &portIdAidl)));
+ *portId = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+ return OK;
}
-status_t AudioSystem::stopAudioSource(audio_port_handle_t portId)
-{
+status_t AudioSystem::stopAudioSource(audio_port_handle_t portId) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->stopAudioSource(portId);
+
+ int32_t portIdAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return statusTFromBinderStatus(aps->stopAudioSource(portIdAidl));
}
-status_t AudioSystem::setMasterMono(bool mono)
-{
+status_t AudioSystem::setMasterMono(bool mono) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setMasterMono(mono);
+ return statusTFromBinderStatus(aps->setMasterMono(mono));
}
-status_t AudioSystem::getMasterMono(bool *mono)
-{
+status_t AudioSystem::getMasterMono(bool* mono) {
+ if (mono == nullptr) {
+ return BAD_VALUE;
+ }
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getMasterMono(mono);
+ return statusTFromBinderStatus(aps->getMasterMono(mono));
}
-status_t AudioSystem::setMasterBalance(float balance)
-{
+status_t AudioSystem::setMasterBalance(float balance) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->setMasterBalance(balance);
}
-status_t AudioSystem::getMasterBalance(float *balance)
-{
+status_t AudioSystem::getMasterBalance(float* balance) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->getMasterBalance(balance);
}
-float AudioSystem::getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
-{
+float
+AudioSystem::getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return NAN;
- return aps->getStreamVolumeDB(stream, index, device);
+
+ auto result = [&]() -> ConversionResult<float> {
+ media::AudioStreamType streamAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ int32_t indexAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(index));
+ int32_t deviceAidl = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(device));
+ float retAidl;
+ RETURN_IF_ERROR(statusTFromBinderStatus(
+ aps->getStreamVolumeDB(streamAidl, indexAidl, deviceAidl, &retAidl)));
+ return retAidl;
+ }();
+ return result.value_or(NAN);
}
-status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfo> *microphones)
-{
+status_t AudioSystem::getMicrophones(std::vector<media::MicrophoneInfo>* microphones) {
const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
if (af == 0) return PERMISSION_DENIED;
return af->getMicrophones(microphones);
}
status_t AudioSystem::setAudioHalPids(const std::vector<pid_t>& pids) {
- const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
- if (af == nullptr) return PERMISSION_DENIED;
- return af->setAudioHalPids(pids);
+ const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();
+ if (af == nullptr) return PERMISSION_DENIED;
+ return af->setAudioHalPids(pids);
}
-status_t AudioSystem::getSurroundFormats(unsigned int *numSurroundFormats,
- audio_format_t *surroundFormats,
- bool *surroundFormatsEnabled,
- bool reported)
-{
+status_t AudioSystem::getSurroundFormats(unsigned int* numSurroundFormats,
+ audio_format_t* surroundFormats,
+ bool* surroundFormatsEnabled,
+ bool reported) {
+ if (numSurroundFormats == nullptr || (*numSurroundFormats != 0 &&
+ (surroundFormats == nullptr ||
+ surroundFormatsEnabled == nullptr))) {
+ return BAD_VALUE;
+ }
+
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getSurroundFormats(
- numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
+
+ media::Int numSurroundFormatsAidl;
+ numSurroundFormatsAidl.value =
+ VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*numSurroundFormats));
+ std::vector<media::audio::common::AudioFormat> surroundFormatsAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getSurroundFormats(reported, &numSurroundFormatsAidl, &surroundFormatsAidl,
+ surroundFormatsEnabled)));
+ *numSurroundFormats = VALUE_OR_RETURN_STATUS(
+ convertIntegral<unsigned int>(numSurroundFormatsAidl.value));
+ RETURN_STATUS_IF_ERROR(
+ convertRange(surroundFormatsAidl.begin(), surroundFormatsAidl.end(), surroundFormats,
+ aidl2legacy_AudioFormat_audio_format_t));
+ return OK;
}
-status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
-{
+status_t AudioSystem::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setSurroundFormatEnabled(audioFormat, enabled);
+
+ media::audio::common::AudioFormat audioFormatAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_format_t_AudioFormat(audioFormat));
+ return statusTFromBinderStatus(
+ aps->setSurroundFormatEnabled(audioFormatAidl, enabled));
}
-status_t AudioSystem::setAssistantUid(uid_t uid)
-{
- const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setAssistantUid(uid_t uid) {
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setAssistantUid(uid);
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ return statusTFromBinderStatus(aps->setAssistantUid(uidAidl));
}
-status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids)
-{
- const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setA11yServicesUids(const std::vector<uid_t>& uids) {
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setA11yServicesUids(uids);
+ std::vector<int32_t> uidsAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<int32_t>>(uids, legacy2aidl_uid_t_int32_t));
+ return statusTFromBinderStatus(aps->setA11yServicesUids(uidsAidl));
}
-status_t AudioSystem::setCurrentImeUid(uid_t uid)
-{
- const sp <IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+status_t AudioSystem::setCurrentImeUid(uid_t uid) {
+ const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setCurrentImeUid(uid);
+ int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_uid_t_int32_t(uid));
+ return statusTFromBinderStatus(aps->setCurrentImeUid(uidAidl));
}
-bool AudioSystem::isHapticPlaybackSupported()
-{
+bool AudioSystem::isHapticPlaybackSupported() {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return false;
- return aps->isHapticPlaybackSupported();
+
+ auto result = [&]() -> ConversionResult<bool> {
+ bool retVal;
+ RETURN_IF_ERROR(
+ statusTFromBinderStatus(aps->isHapticPlaybackSupported(&retVal)));
+ return retVal;
+ }();
+ return result.value_or(false);
}
status_t AudioSystem::getHwOffloadEncodingFormatsSupportedForA2DP(
- std::vector<audio_format_t> *formats) {
- const sp <IAudioPolicyService>
- & aps = AudioSystem::get_audio_policy_service();
+ std::vector<audio_format_t>* formats) {
+ if (formats == nullptr) {
+ return BAD_VALUE;
+ }
+
+ const sp<IAudioPolicyService>
+ & aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
+
+ std::vector<media::audio::common::AudioFormat> formatsAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getHwOffloadEncodingFormatsSupportedForA2DP(&formatsAidl)));
+ *formats = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<audio_format_t>>(formatsAidl,
+ aidl2legacy_AudioFormat_audio_format_t));
+ return OK;
}
-status_t AudioSystem::listAudioProductStrategies(AudioProductStrategyVector &strategies)
-{
+status_t AudioSystem::listAudioProductStrategies(AudioProductStrategyVector& strategies) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->listAudioProductStrategies(strategies);
+
+ std::vector<media::AudioProductStrategy> strategiesAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->listAudioProductStrategies(&strategiesAidl)));
+ strategies = VALUE_OR_RETURN_STATUS(
+ convertContainer<AudioProductStrategyVector>(strategiesAidl,
+ aidl2legacy_AudioProductStrategy));
+ return OK;
}
-audio_attributes_t AudioSystem::streamTypeToAttributes(audio_stream_type_t stream)
-{
+audio_attributes_t AudioSystem::streamTypeToAttributes(audio_stream_type_t stream) {
AudioProductStrategyVector strategies;
listAudioProductStrategies(strategies);
- for (const auto &strategy : strategies) {
+ for (const auto& strategy : strategies) {
auto attrVect = strategy.getAudioAttributes();
- auto iter = std::find_if(begin(attrVect), end(attrVect), [&stream](const auto &attributes) {
- return attributes.getStreamType() == stream; });
+ auto iter = std::find_if(begin(attrVect), end(attrVect), [&stream](const auto& attributes) {
+ return attributes.getStreamType() == stream;
+ });
if (iter != end(attrVect)) {
return iter->getAttributes();
}
}
- ALOGE("invalid stream type %s when converting to attributes", toString(stream).c_str());
+ ALOGE("invalid stream type %s when converting to attributes", toString(stream).c_str());
return AUDIO_ATTRIBUTES_INITIALIZER;
}
-audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t &attr)
-{
+audio_stream_type_t AudioSystem::attributesToStreamType(const audio_attributes_t& attr) {
product_strategy_t psId;
status_t ret = AudioSystem::getProductStrategyFromAudioAttributes(AudioAttributes(attr), psId);
if (ret != NO_ERROR) {
- ALOGE("no strategy found for attributes %s", toString(attr).c_str());
+ ALOGE("no strategy found for attributes %s", toString(attr).c_str());
return AUDIO_STREAM_MUSIC;
}
AudioProductStrategyVector strategies;
listAudioProductStrategies(strategies);
- for (const auto &strategy : strategies) {
+ for (const auto& strategy : strategies) {
if (strategy.getId() == psId) {
auto attrVect = strategy.getAudioAttributes();
- auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto &refAttr) {
- return AudioProductStrategy::attributesMatches(
- refAttr.getAttributes(), attr); });
+ auto iter = std::find_if(begin(attrVect), end(attrVect), [&attr](const auto& refAttr) {
+ return AudioProductStrategy::attributesMatches(
+ refAttr.getAttributes(), attr);
+ });
if (iter != end(attrVect)) {
return iter->getStreamType();
}
@@ -1585,131 +1982,201 @@
// virtual source is not expected to have an associated product strategy
break;
default:
- ALOGE("invalid attributes %s when converting to stream", toString(attr).c_str());
+ ALOGE("invalid attributes %s when converting to stream", toString(attr).c_str());
break;
}
return AUDIO_STREAM_MUSIC;
}
-status_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
- product_strategy_t &productStrategy)
-{
+status_t AudioSystem::getProductStrategyFromAudioAttributes(const AudioAttributes& aa,
+ product_strategy_t& productStrategy) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getProductStrategyFromAudioAttributes(aa,productStrategy);
+
+ media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+ int32_t productStrategyAidl;
+
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getProductStrategyFromAudioAttributes(aaAidl, &productStrategyAidl)));
+ productStrategy = VALUE_OR_RETURN_STATUS(
+ aidl2legacy_int32_t_product_strategy_t(productStrategyAidl));
+ return OK;
}
-status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
-{
+status_t AudioSystem::listAudioVolumeGroups(AudioVolumeGroupVector& groups) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->listAudioVolumeGroups(groups);
+
+ std::vector<media::AudioVolumeGroup> groupsAidl;
+ RETURN_STATUS_IF_ERROR(
+ statusTFromBinderStatus(aps->listAudioVolumeGroups(&groupsAidl)));
+ groups = VALUE_OR_RETURN_STATUS(
+ convertContainer<AudioVolumeGroupVector>(groupsAidl, aidl2legacy_AudioVolumeGroup));
+ return OK;
}
-status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
- volume_group_t &volumeGroup)
-{
+status_t AudioSystem::getVolumeGroupFromAudioAttributes(const AudioAttributes& aa,
+ volume_group_t& volumeGroup) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
+
+ media::AudioAttributesEx aaAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_AudioAttributes_AudioAttributesEx(aa));
+ int32_t volumeGroupAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getVolumeGroupFromAudioAttributes(aaAidl, &volumeGroupAidl)));
+ volumeGroup = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_volume_group_t(volumeGroupAidl));
+ return OK;
}
-status_t AudioSystem::setRttEnabled(bool enabled)
-{
+status_t AudioSystem::setRttEnabled(bool enabled) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return PERMISSION_DENIED;
- return aps->setRttEnabled(enabled);
+ return statusTFromBinderStatus(aps->setRttEnabled(enabled));
}
-bool AudioSystem::isCallScreenModeSupported()
-{
+bool AudioSystem::isCallScreenModeSupported() {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return false;
- return aps->isCallScreenModeSupported();
+
+ auto result = [&]() -> ConversionResult<bool> {
+ bool retAidl;
+ RETURN_IF_ERROR(
+ statusTFromBinderStatus(aps->isCallScreenModeSupported(&retAidl)));
+ return retAidl;
+ }();
+ return result.value_or(false);
}
status_t AudioSystem::setDevicesRoleForStrategy(product_strategy_t strategy,
device_role_t role,
- const AudioDeviceTypeAddrVector &devices)
-{
+ const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->setDevicesRoleForStrategy(strategy, role, devices);
+
+ int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(
+ aps->setDevicesRoleForStrategy(strategyAidl, roleAidl, devicesAidl));
}
-status_t AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
-{
+status_t
+AudioSystem::removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->removeDevicesRoleForStrategy(strategy, role);
+ int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ return statusTFromBinderStatus(
+ aps->removeDevicesRoleForStrategy(strategyAidl, roleAidl));
}
status_t AudioSystem::getDevicesForRoleAndStrategy(product_strategy_t strategy,
device_role_t role,
- AudioDeviceTypeAddrVector &devices)
-{
+ AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->getDevicesForRoleAndStrategy(strategy, role, devices);
+ int32_t strategyAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_product_strategy_t_int32_t(strategy));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getDevicesForRoleAndStrategy(strategyAidl, roleAidl, &devicesAidl)));
+ devices = VALUE_OR_RETURN_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+ return OK;
}
status_t AudioSystem::setDevicesRoleForCapturePreset(audio_source_t audioSource,
device_role_t role,
- const AudioDeviceTypeAddrVector &devices)
-{
+ const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->setDevicesRoleForCapturePreset(audioSource, role, devices);
+
+ media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(
+ aps->setDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
}
status_t AudioSystem::addDevicesRoleForCapturePreset(audio_source_t audioSource,
device_role_t role,
- const AudioDeviceTypeAddrVector &devices)
-{
+ const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->addDevicesRoleForCapturePreset(audioSource, role, devices);
+ media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(
+ aps->addDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
}
status_t AudioSystem::removeDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
-{
+ audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->removeDevicesRoleForCapturePreset(audioSource, role, devices);
+ media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl = VALUE_OR_RETURN_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return statusTFromBinderStatus(
+ aps->removeDevicesRoleForCapturePreset(audioSourceAidl, roleAidl, devicesAidl));
}
status_t AudioSystem::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role)
-{
+ device_role_t role) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->clearDevicesRoleForCapturePreset(audioSource, role);
+ media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ return statusTFromBinderStatus(
+ aps->clearDevicesRoleForCapturePreset(audioSourceAidl, roleAidl));
}
status_t AudioSystem::getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
device_role_t role,
- AudioDeviceTypeAddrVector &devices)
-{
+ AudioDeviceTypeAddrVector& devices) {
const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) {
return PERMISSION_DENIED;
}
- return aps->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
+ media::AudioSourceType audioSourceAidl = VALUE_OR_RETURN_STATUS(
+ legacy2aidl_audio_source_t_AudioSourceType(audioSource));
+ media::DeviceRole roleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_device_role_t_DeviceRole(role));
+ std::vector<media::AudioDevice> devicesAidl;
+ RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
+ aps->getDevicesForRoleAndCapturePreset(audioSourceAidl, roleAidl, &devicesAidl)));
+ devices = VALUE_OR_RETURN_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+ return OK;
}
class CaptureStateListenerImpl : public media::BnCaptureStateListener,
@@ -1722,7 +2189,8 @@
void init() {
bool active;
- status_t status = mAps->registerSoundTriggerCaptureStateListener(this, &active);
+ status_t status = statusTFromBinderStatus(
+ mAps->registerSoundTriggerCaptureStateListener(this, &active));
if (status != NO_ERROR) {
mListener->onServiceDied();
return;
@@ -1750,7 +2218,7 @@
};
status_t AudioSystem::registerSoundTriggerCaptureStateListener(
- const sp<CaptureStateListener>& listener) {
+ const sp<CaptureStateListener>& listener) {
LOG_ALWAYS_FATAL_IF(listener == nullptr);
const sp<IAudioPolicyService>& aps =
@@ -1769,8 +2237,7 @@
// ---------------------------------------------------------------------------
int AudioSystem::AudioPolicyServiceClient::addAudioPortCallback(
- const sp<AudioPortCallback>& callback)
-{
+ const sp<AudioPortCallback>& callback) {
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
if (mAudioPortCallbacks[i] == callback) {
@@ -1782,8 +2249,7 @@
}
int AudioSystem::AudioPolicyServiceClient::removeAudioPortCallback(
- const sp<AudioPortCallback>& callback)
-{
+ const sp<AudioPortCallback>& callback) {
Mutex::Autolock _l(mLock);
size_t i;
for (i = 0; i < mAudioPortCallbacks.size(); i++) {
@@ -1799,8 +2265,7 @@
}
-Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate()
-{
+Status AudioSystem::AudioPolicyServiceClient::onAudioPortListUpdate() {
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onAudioPortListUpdate();
@@ -1808,8 +2273,7 @@
return Status::ok();
}
-Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate()
-{
+Status AudioSystem::AudioPolicyServiceClient::onAudioPatchListUpdate() {
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
mAudioPortCallbacks[i]->onAudioPatchListUpdate();
@@ -1819,8 +2283,7 @@
// ----------------------------------------------------------------------------
int AudioSystem::AudioPolicyServiceClient::addAudioVolumeGroupCallback(
- const sp<AudioVolumeGroupCallback>& callback)
-{
+ const sp<AudioVolumeGroupCallback>& callback) {
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
if (mAudioVolumeGroupCallback[i] == callback) {
@@ -1832,8 +2295,7 @@
}
int AudioSystem::AudioPolicyServiceClient::removeAudioVolumeGroupCallback(
- const sp<AudioVolumeGroupCallback>& callback)
-{
+ const sp<AudioVolumeGroupCallback>& callback) {
Mutex::Autolock _l(mLock);
size_t i;
for (i = 0; i < mAudioVolumeGroupCallback.size(); i++) {
@@ -1934,8 +2396,7 @@
return Status::ok();
}
-void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused)
-{
+void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who __unused) {
{
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mAudioPortCallbacks.size(); i++) {
diff --git a/media/libaudioclient/AudioTrack.cpp b/media/libaudioclient/AudioTrack.cpp
index d4cbbc3..b1eb950 100644
--- a/media/libaudioclient/AudioTrack.cpp
+++ b/media/libaudioclient/AudioTrack.cpp
@@ -22,6 +22,7 @@
#include <math.h>
#include <sys/resource.h>
+#include <android/media/IAudioPolicyService.h>
#include <android-base/macros.h>
#include <audio_utils/clock.h>
#include <audio_utils/primitives.h>
@@ -31,7 +32,6 @@
#include <private/media/AudioTrackShared.h>
#include <processgroup/sched_policy.h>
#include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
#include <media/AudioParameter.h>
#include <media/AudioResamplerPublic.h>
#include <media/AudioSystem.h>
@@ -172,9 +172,20 @@
bool AudioTrack::isDirectOutputSupported(const audio_config_base_t& config,
const audio_attributes_t& attributes) {
ALOGV("%s()", __FUNCTION__);
- const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
+ const sp<media::IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();
if (aps == 0) return false;
- return aps->isDirectOutputSupported(config, attributes);
+
+ auto result = [&]() -> ConversionResult<bool> {
+ media::AudioConfigBase configAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_config_base_t_AudioConfigBase(config));
+ media::AudioAttributesInternal attributesAidl = VALUE_OR_RETURN(
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal(attributes));
+ bool retAidl;
+ RETURN_IF_ERROR(aidl_utils::statusTFromBinderStatus(
+ aps->isDirectOutputSupported(configAidl, attributesAidl, &retAidl)));
+ return retAidl;
+ }();
+ return result.value_or(false);
}
// ---------------------------------------------------------------------------
diff --git a/media/libaudioclient/AudioVolumeGroup.cpp b/media/libaudioclient/AudioVolumeGroup.cpp
index e79a362..361f7b8 100644
--- a/media/libaudioclient/AudioVolumeGroup.cpp
+++ b/media/libaudioclient/AudioVolumeGroup.cpp
@@ -21,64 +21,57 @@
#include <utils/Log.h>
#include <binder/Parcel.h>
+#include <media/AidlConversion.h>
#include <media/AudioVolumeGroup.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 AudioVolumeGroup::readFromParcel(const Parcel *parcel)
{
- status_t ret = parcel->readUtf8FromUtf16(&mName);
- if (ret != NO_ERROR) {
- return ret;
- }
- mGroupId = static_cast<volume_group_t>(parcel->readInt32());
- size_t size = static_cast<size_t>(parcel->readInt32());
- for (size_t i = 0; i < size; i++) {
- AudioAttributes attribute;
- attribute.readFromParcel(parcel);
- if (ret != NO_ERROR) {
- mAudioAttributes.clear();
- return ret;
- }
- mAudioAttributes.push_back(attribute.getAttributes());
- }
- size = static_cast<size_t>(parcel->readInt32());
- for (size_t i = 0; i < size; i++) {
- audio_stream_type_t stream = static_cast<audio_stream_type_t>(parcel->readInt32());
- mStreams.push_back(stream);
- }
- return NO_ERROR;
+ media::AudioVolumeGroup aidl;
+ RETURN_STATUS_IF_ERROR(aidl.readFromParcel(parcel));
+ *this = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioVolumeGroup(aidl));
+ return OK;
}
status_t AudioVolumeGroup::writeToParcel(Parcel *parcel) const
{
- parcel->writeUtf8AsUtf16(mName);
- parcel->writeInt32(static_cast<int32_t>(mGroupId));
- size_t size = mAudioAttributes.size();
- size_t sizePosition = parcel->dataPosition();
- parcel->writeInt32(size);
- size_t finalSize = size;
- for (const auto &attributes : mAudioAttributes) {
- size_t position = parcel->dataPosition();
- AudioAttributes attribute(attributes);
- status_t ret = attribute.writeToParcel(parcel);
- if (ret != NO_ERROR) {
- parcel->setDataPosition(position);
- finalSize--;
- }
- }
- if (size != finalSize) {
- size_t position = parcel->dataPosition();
- parcel->setDataPosition(sizePosition);
- parcel->writeInt32(finalSize);
- parcel->setDataPosition(position);
- }
- parcel->writeInt32(mStreams.size());
- for (const auto &stream : mStreams) {
- parcel->writeInt32(static_cast<int32_t>(stream));
- }
- return NO_ERROR;
+ media::AudioVolumeGroup aidl = VALUE_OR_RETURN_STATUS(legacy2aidl_AudioVolumeGroup(*this));
+ return aidl.writeToParcel(parcel);
+}
+
+ConversionResult<media::AudioVolumeGroup>
+legacy2aidl_AudioVolumeGroup(const AudioVolumeGroup& legacy) {
+ media::AudioVolumeGroup aidl;
+ aidl.groupId = VALUE_OR_RETURN(legacy2aidl_volume_group_t_int32_t(legacy.getId()));
+ aidl.name = legacy.getName();
+ aidl.audioAttributes = VALUE_OR_RETURN(
+ convertContainer<std::vector<media::AudioAttributesInternal>>(
+ legacy.getAudioAttributes(),
+ legacy2aidl_audio_attributes_t_AudioAttributesInternal));
+ aidl.streams = VALUE_OR_RETURN(
+ convertContainer<std::vector<media::AudioStreamType>>(legacy.getStreamTypes(),
+ legacy2aidl_audio_stream_type_t_AudioStreamType));
+ return aidl;
+}
+
+ConversionResult<AudioVolumeGroup>
+aidl2legacy_AudioVolumeGroup(const media::AudioVolumeGroup& aidl) {
+ return AudioVolumeGroup(
+ aidl.name,
+ VALUE_OR_RETURN(aidl2legacy_int32_t_volume_group_t(aidl.groupId)),
+ VALUE_OR_RETURN(convertContainer<AttributesVector>(
+ aidl.audioAttributes,
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t)),
+ VALUE_OR_RETURN(convertContainer<StreamTypeVector>(
+ aidl.streams,
+ aidl2legacy_AudioStreamType_audio_stream_type_t))
+ );
}
} // namespace android
diff --git a/media/libaudioclient/IAudioPolicyService.cpp b/media/libaudioclient/IAudioPolicyService.cpp
deleted file mode 100644
index 0849e61..0000000
--- a/media/libaudioclient/IAudioPolicyService.cpp
+++ /dev/null
@@ -1,2982 +0,0 @@
-/*
-**
-** Copyright 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 "IAudioPolicyService"
-#include <utils/Log.h>
-
-#include <stdint.h>
-#include <math.h>
-#include <sys/types.h>
-
-#include <android/media/ICaptureStateListener.h>
-#include <binder/IPCThreadState.h>
-#include <binder/Parcel.h>
-#include <media/AudioEffect.h>
-#include <media/AudioValidator.h>
-#include <media/IAudioPolicyService.h>
-#include <mediautils/ServiceUtilities.h>
-#include <mediautils/TimeCheck.h>
-#include <system/audio.h>
-
-namespace android {
-
-using media::ICaptureStateListener;
-
-enum {
- SET_DEVICE_CONNECTION_STATE = IBinder::FIRST_CALL_TRANSACTION,
- GET_DEVICE_CONNECTION_STATE,
- HANDLE_DEVICE_CONFIG_CHANGE,
- SET_PHONE_STATE,
- SET_RINGER_MODE, // reserved, no longer used
- SET_FORCE_USE,
- GET_FORCE_USE,
- GET_OUTPUT,
- START_OUTPUT,
- STOP_OUTPUT,
- RELEASE_OUTPUT,
- GET_INPUT_FOR_ATTR,
- START_INPUT,
- STOP_INPUT,
- RELEASE_INPUT,
- INIT_STREAM_VOLUME,
- SET_STREAM_VOLUME,
- GET_STREAM_VOLUME,
- SET_VOLUME_ATTRIBUTES,
- GET_VOLUME_ATTRIBUTES,
- GET_MIN_VOLUME_FOR_ATTRIBUTES,
- GET_MAX_VOLUME_FOR_ATTRIBUTES,
- GET_STRATEGY_FOR_STREAM,
- GET_OUTPUT_FOR_EFFECT,
- REGISTER_EFFECT,
- UNREGISTER_EFFECT,
- IS_STREAM_ACTIVE,
- IS_SOURCE_ACTIVE,
- GET_DEVICES_FOR_STREAM,
- QUERY_DEFAULT_PRE_PROCESSING,
- SET_EFFECT_ENABLED,
- IS_STREAM_ACTIVE_REMOTELY,
- GET_OFFLOAD_MODE_SUPPORTED,
- IS_DIRECT_OUTPUT_SUPPORTED,
- LIST_AUDIO_PORTS,
- GET_AUDIO_PORT,
- CREATE_AUDIO_PATCH,
- RELEASE_AUDIO_PATCH,
- LIST_AUDIO_PATCHES,
- SET_AUDIO_PORT_CONFIG,
- REGISTER_CLIENT,
- GET_OUTPUT_FOR_ATTR,
- ACQUIRE_SOUNDTRIGGER_SESSION,
- RELEASE_SOUNDTRIGGER_SESSION,
- GET_PHONE_STATE,
- REGISTER_POLICY_MIXES,
- START_AUDIO_SOURCE,
- STOP_AUDIO_SOURCE,
- SET_AUDIO_PORT_CALLBACK_ENABLED,
- SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED,
- SET_MASTER_MONO,
- GET_MASTER_MONO,
- GET_STREAM_VOLUME_DB,
- GET_SURROUND_FORMATS,
- SET_SURROUND_FORMAT_ENABLED,
- ADD_STREAM_DEFAULT_EFFECT,
- REMOVE_STREAM_DEFAULT_EFFECT,
- ADD_SOURCE_DEFAULT_EFFECT,
- REMOVE_SOURCE_DEFAULT_EFFECT,
- SET_ASSISTANT_UID,
- SET_A11Y_SERVICES_UIDS,
- IS_HAPTIC_PLAYBACK_SUPPORTED,
- SET_UID_DEVICE_AFFINITY,
- REMOVE_UID_DEVICE_AFFINITY,
- SET_USERID_DEVICE_AFFINITY,
- REMOVE_USERID_DEVICE_AFFINITY,
- GET_OFFLOAD_FORMATS_A2DP,
- LIST_AUDIO_PRODUCT_STRATEGIES,
- GET_STRATEGY_FOR_ATTRIBUTES,
- LIST_AUDIO_VOLUME_GROUPS,
- GET_VOLUME_GROUP_FOR_ATTRIBUTES,
- SET_SUPPORTED_SYSTEM_USAGES,
- SET_ALLOWED_CAPTURE_POLICY,
- MOVE_EFFECTS_TO_IO,
- SET_RTT_ENABLED,
- IS_CALL_SCREEN_MODE_SUPPORTED,
- SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
- REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
- GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
- GET_DEVICES_FOR_ATTRIBUTES,
- AUDIO_MODULES_UPDATED, // oneway
- SET_CURRENT_IME_UID,
- REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER,
- SET_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET,
-};
-
-#define MAX_ITEMS_PER_LIST 1024
-
-class BpAudioPolicyService : public BpInterface<IAudioPolicyService>
-{
-public:
- explicit BpAudioPolicyService(const sp<IBinder>& impl)
- : BpInterface<IAudioPolicyService>(impl)
- {
- }
-
- virtual status_t setDeviceConnectionState(
- audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(device));
- data.writeInt32(static_cast <uint32_t>(state));
- data.writeCString(device_address);
- data.writeCString(device_name);
- data.writeInt32(static_cast <uint32_t>(encodedFormat));
- remote()->transact(SET_DEVICE_CONNECTION_STATE, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual audio_policy_dev_state_t getDeviceConnectionState(
- audio_devices_t device,
- const char *device_address)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(device));
- data.writeCString(device_address);
- remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply);
- return static_cast <audio_policy_dev_state_t>(reply.readInt32());
- }
-
- virtual status_t handleDeviceConfigChange(audio_devices_t device,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(device));
- data.writeCString(device_address);
- data.writeCString(device_name);
- data.writeInt32(static_cast <uint32_t>(encodedFormat));
- remote()->transact(HANDLE_DEVICE_CONFIG_CHANGE, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setPhoneState(audio_mode_t state, uid_t uid)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(state);
- data.writeInt32(uid);
- remote()->transact(SET_PHONE_STATE, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(usage));
- data.writeInt32(static_cast <uint32_t>(config));
- remote()->transact(SET_FORCE_USE, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(usage));
- remote()->transact(GET_FORCE_USE, data, &reply);
- return static_cast <audio_policy_forced_cfg_t> (reply.readInt32());
- }
-
- virtual audio_io_handle_t getOutput(audio_stream_type_t stream)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- remote()->transact(GET_OUTPUT, data, &reply);
- return static_cast <audio_io_handle_t> (reply.readInt32());
- }
-
- status_t getOutputForAttr(audio_attributes_t *attr,
- audio_io_handle_t *output,
- audio_session_t session,
- audio_stream_type_t *stream,
- pid_t pid,
- uid_t uid,
- const audio_config_t *config,
- audio_output_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId,
- std::vector<audio_io_handle_t> *secondaryOutputs) override
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- if (attr == nullptr) {
- ALOGE("%s NULL audio attributes", __func__);
- return BAD_VALUE;
- }
- if (output == nullptr) {
- ALOGE("%s NULL output - shouldn't happen", __func__);
- return BAD_VALUE;
- }
- if (selectedDeviceId == nullptr) {
- ALOGE("%s NULL selectedDeviceId - shouldn't happen", __func__);
- return BAD_VALUE;
- }
- if (portId == nullptr) {
- ALOGE("%s NULL portId - shouldn't happen", __func__);
- return BAD_VALUE;
- }
- if (secondaryOutputs == nullptr) {
- ALOGE("%s NULL secondaryOutputs - shouldn't happen", __func__);
- return BAD_VALUE;
- }
- data.write(attr, sizeof(audio_attributes_t));
- data.writeInt32(session);
- if (stream == NULL) {
- data.writeInt32(0);
- } else {
- data.writeInt32(1);
- data.writeInt32(*stream);
- }
- data.writeInt32(pid);
- data.writeInt32(uid);
- data.write(config, sizeof(audio_config_t));
- data.writeInt32(static_cast <uint32_t>(flags));
- data.writeInt32(*selectedDeviceId);
- data.writeInt32(*portId);
- status_t status = remote()->transact(GET_OUTPUT_FOR_ATTR, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = (status_t)reply.readInt32();
- if (status != NO_ERROR) {
- return status;
- }
- status = (status_t)reply.read(&attr, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
- *output = (audio_io_handle_t)reply.readInt32();
- audio_stream_type_t lStream = (audio_stream_type_t)reply.readInt32();
- if (stream != NULL) {
- *stream = lStream;
- }
- *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
- *portId = (audio_port_handle_t)reply.readInt32();
- secondaryOutputs->resize(reply.readInt32());
- return reply.read(secondaryOutputs->data(),
- secondaryOutputs->size() * sizeof(audio_io_handle_t));
- }
-
- virtual status_t startOutput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t)portId);
- remote()->transact(START_OUTPUT, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t stopOutput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t)portId);
- remote()->transact(STOP_OUTPUT, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual void releaseOutput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t)portId);
- remote()->transact(RELEASE_OUTPUT, data, &reply);
- }
-
- virtual status_t getInputForAttr(const audio_attributes_t *attr,
- audio_io_handle_t *input,
- audio_unique_id_t riid,
- audio_session_t session,
- pid_t pid,
- uid_t uid,
- const String16& opPackageName,
- const audio_config_base_t *config,
- audio_input_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- if (attr == NULL) {
- ALOGE("getInputForAttr NULL attr - shouldn't happen");
- return BAD_VALUE;
- }
- if (input == NULL) {
- ALOGE("getInputForAttr NULL input - shouldn't happen");
- return BAD_VALUE;
- }
- if (selectedDeviceId == NULL) {
- ALOGE("getInputForAttr NULL selectedDeviceId - shouldn't happen");
- return BAD_VALUE;
- }
- if (portId == NULL) {
- ALOGE("getInputForAttr NULL portId - shouldn't happen");
- return BAD_VALUE;
- }
-
- data.write(attr, sizeof(audio_attributes_t));
- data.writeInt32(*input);
- data.writeInt32(riid);
- data.writeInt32(session);
- data.writeInt32(pid);
- data.writeInt32(uid);
- data.writeString16(opPackageName);
- data.write(config, sizeof(audio_config_base_t));
- data.writeInt32(flags);
- data.writeInt32(*selectedDeviceId);
- data.writeInt32(*portId);
- status_t status = remote()->transact(GET_INPUT_FOR_ATTR, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = reply.readInt32();
- if (status != NO_ERROR) {
- return status;
- }
- *input = (audio_io_handle_t)reply.readInt32();
- *selectedDeviceId = (audio_port_handle_t)reply.readInt32();
- *portId = (audio_port_handle_t)reply.readInt32();
- return NO_ERROR;
- }
-
- virtual status_t startInput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(portId);
- remote()->transact(START_INPUT, data, &reply);
- status_t status = static_cast <status_t> (reply.readInt32());
- return status;
- }
-
- virtual status_t stopInput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(portId);
- remote()->transact(STOP_INPUT, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual void releaseInput(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(portId);
- remote()->transact(RELEASE_INPUT, data, &reply);
- }
-
- virtual status_t initStreamVolume(audio_stream_type_t stream,
- int indexMin,
- int indexMax)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- data.writeInt32(indexMin);
- data.writeInt32(indexMax);
- remote()->transact(INIT_STREAM_VOLUME, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- data.writeInt32(index);
- data.writeInt32(static_cast <uint32_t>(device));
- remote()->transact(SET_STREAM_VOLUME, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
- int *index,
- audio_devices_t device)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- data.writeInt32(static_cast <uint32_t>(device));
-
- remote()->transact(GET_STREAM_VOLUME, data, &reply);
- int lIndex = reply.readInt32();
- if (index) *index = lIndex;
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, int index,
- audio_devices_t device)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&attr, sizeof(audio_attributes_t));
- data.writeInt32(index);
- data.writeInt32(static_cast <uint32_t>(device));
- status_t status = remote()->transact(SET_VOLUME_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
- virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, int &index,
- audio_devices_t device)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&attr, sizeof(audio_attributes_t));
- data.writeInt32(static_cast <uint32_t>(device));
- status_t status = remote()->transact(GET_VOLUME_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- index = reply.readInt32();
- return NO_ERROR;
- }
- virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&attr, sizeof(audio_attributes_t));
- status_t status = remote()->transact(GET_MIN_VOLUME_FOR_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- index = reply.readInt32();
- return NO_ERROR;
- }
- virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&attr, sizeof(audio_attributes_t));
- status_t status = remote()->transact(GET_MAX_VOLUME_FOR_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- index = reply.readInt32();
- return NO_ERROR;
- }
- virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- remote()->transact(GET_STRATEGY_FOR_STREAM, data, &reply);
- return reply.readUint32();
- }
-
- virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <uint32_t>(stream));
- remote()->transact(GET_DEVICES_FOR_STREAM, data, &reply);
- return (audio_devices_t) reply.readInt32();
- }
-
- virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(desc, sizeof(effect_descriptor_t));
- status_t status = remote()->transact(GET_OUTPUT_FOR_EFFECT, data, &reply);
- if (status != NO_ERROR ||
- (status = (status_t)reply.readInt32()) != NO_ERROR) {
- return AUDIO_IO_HANDLE_NONE;
- }
- return static_cast <audio_io_handle_t> (reply.readInt32());
- }
-
- virtual status_t registerEffect(const effect_descriptor_t *desc,
- audio_io_handle_t io,
- uint32_t strategy,
- audio_session_t session,
- int id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(desc, sizeof(effect_descriptor_t));
- data.writeInt32(io);
- data.writeInt32(strategy);
- data.writeInt32(session);
- data.writeInt32(id);
- remote()->transact(REGISTER_EFFECT, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t unregisterEffect(int id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(id);
- remote()->transact(UNREGISTER_EFFECT, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setEffectEnabled(int id, bool enabled)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(id);
- data.writeInt32(enabled);
- remote()->transact(SET_EFFECT_ENABLED, data, &reply);
- return static_cast <status_t> (reply.readInt32());
- }
-
- status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(ids.size());
- for (auto id : ids) {
- data.writeInt32(id);
- }
- data.writeInt32(io);
- status_t status = remote()->transact(MOVE_EFFECTS_TO_IO, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t) stream);
- data.writeInt32(inPastMs);
- remote()->transact(IS_STREAM_ACTIVE, data, &reply);
- return reply.readInt32();
- }
-
- virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t) stream);
- data.writeInt32(inPastMs);
- remote()->transact(IS_STREAM_ACTIVE_REMOTELY, data, &reply);
- return reply.readInt32();
- }
-
- virtual bool isSourceActive(audio_source_t source) const
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32((int32_t) source);
- remote()->transact(IS_SOURCE_ACTIVE, data, &reply);
- return reply.readInt32();
- }
-
- virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
- effect_descriptor_t *descriptors,
- uint32_t *count)
- {
- if (descriptors == NULL || count == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(audioSession);
- data.writeInt32(*count);
- status_t status = remote()->transact(QUERY_DEFAULT_PRE_PROCESSING, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- uint32_t retCount = reply.readInt32();
- if (retCount != 0) {
- uint32_t numDesc = (retCount < *count) ? retCount : *count;
- reply.read(descriptors, sizeof(effect_descriptor_t) * numDesc);
- }
- *count = retCount;
- return status;
- }
-
- status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(systemUsages.size());
- for (auto systemUsage : systemUsages) {
- data.writeInt32(systemUsage);
- }
- status_t status = remote()->transact(SET_SUPPORTED_SYSTEM_USAGES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) override {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(uid);
- data.writeInt32(flags);
- remote()->transact(SET_ALLOWED_CAPTURE_POLICY, data, &reply);
- return reply.readInt32();
- }
-
- virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&info, sizeof(audio_offload_info_t));
- remote()->transact(GET_OFFLOAD_MODE_SUPPORTED, data, &reply);
- return static_cast<audio_offload_mode_t>(reply.readInt32());
- }
-
- virtual bool isDirectOutputSupported(const audio_config_base_t& config,
- const audio_attributes_t& attributes) {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&config, sizeof(audio_config_base_t));
- data.write(&attributes, sizeof(audio_attributes_t));
- status_t status = remote()->transact(IS_DIRECT_OUTPUT_SUPPORTED, data, &reply);
- return status == NO_ERROR ? static_cast<bool>(reply.readInt32()) : false;
- }
-
- virtual status_t listAudioPorts(audio_port_role_t role,
- audio_port_type_t type,
- unsigned int *num_ports,
- struct audio_port_v7 *ports,
- unsigned int *generation)
- {
- if (num_ports == NULL || (*num_ports != 0 && ports == NULL) ||
- generation == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- unsigned int numPortsReq = (ports == NULL) ? 0 : *num_ports;
- data.writeInt32(role);
- data.writeInt32(type);
- data.writeInt32(numPortsReq);
- status_t status = remote()->transact(LIST_AUDIO_PORTS, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t)reply.readInt32();
- *num_ports = (unsigned int)reply.readInt32();
- }
- if (status == NO_ERROR) {
- if (numPortsReq > *num_ports) {
- numPortsReq = *num_ports;
- }
- if (numPortsReq > 0) {
- reply.read(ports, numPortsReq * sizeof(struct audio_port_v7));
- }
- *generation = reply.readInt32();
- }
- return status;
- }
-
- virtual status_t getAudioPort(struct audio_port_v7 *port)
- {
- if (port == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(port, sizeof(struct audio_port_v7));
- status_t status = remote()->transact(GET_AUDIO_PORT, data, &reply);
- if (status != NO_ERROR ||
- (status = (status_t)reply.readInt32()) != NO_ERROR) {
- return status;
- }
- reply.read(port, sizeof(struct audio_port_v7));
- return status;
- }
-
- virtual status_t createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle)
- {
- if (patch == NULL || handle == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(patch, sizeof(struct audio_patch));
- data.write(handle, sizeof(audio_patch_handle_t));
- status_t status = remote()->transact(CREATE_AUDIO_PATCH, data, &reply);
- if (status != NO_ERROR ||
- (status = (status_t)reply.readInt32()) != NO_ERROR) {
- return status;
- }
- reply.read(handle, sizeof(audio_patch_handle_t));
- return status;
- }
-
- virtual status_t releaseAudioPatch(audio_patch_handle_t handle)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(&handle, sizeof(audio_patch_handle_t));
- status_t status = remote()->transact(RELEASE_AUDIO_PATCH, data, &reply);
- if (status != NO_ERROR) {
- status = (status_t)reply.readInt32();
- }
- return status;
- }
-
- virtual status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches,
- unsigned int *generation)
- {
- if (num_patches == NULL || (*num_patches != 0 && patches == NULL) ||
- generation == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- unsigned int numPatchesReq = (patches == NULL) ? 0 : *num_patches;
- data.writeInt32(numPatchesReq);
- status_t status = remote()->transact(LIST_AUDIO_PATCHES, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t)reply.readInt32();
- *num_patches = (unsigned int)reply.readInt32();
- }
- if (status == NO_ERROR) {
- if (numPatchesReq > *num_patches) {
- numPatchesReq = *num_patches;
- }
- if (numPatchesReq > 0) {
- reply.read(patches, numPatchesReq * sizeof(struct audio_patch));
- }
- *generation = reply.readInt32();
- }
- return status;
- }
-
- virtual status_t setAudioPortConfig(const struct audio_port_config *config)
- {
- if (config == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(config, sizeof(struct audio_port_config));
- status_t status = remote()->transact(SET_AUDIO_PORT_CONFIG, data, &reply);
- if (status != NO_ERROR) {
- status = (status_t)reply.readInt32();
- }
- return status;
- }
-
- virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeStrongBinder(IInterface::asBinder(client));
- remote()->transact(REGISTER_CLIENT, data, &reply);
- }
-
- virtual void setAudioPortCallbacksEnabled(bool enabled)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(enabled ? 1 : 0);
- remote()->transact(SET_AUDIO_PORT_CALLBACK_ENABLED, data, &reply);
- }
-
- virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(enabled ? 1 : 0);
- remote()->transact(SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED, data, &reply);
- }
-
- virtual status_t acquireSoundTriggerSession(audio_session_t *session,
- audio_io_handle_t *ioHandle,
- audio_devices_t *device)
- {
- if (session == NULL || ioHandle == NULL || device == NULL) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = remote()->transact(ACQUIRE_SOUNDTRIGGER_SESSION, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = (status_t)reply.readInt32();
- if (status == NO_ERROR) {
- *session = (audio_session_t)reply.readInt32();
- *ioHandle = (audio_io_handle_t)reply.readInt32();
- *device = (audio_devices_t)reply.readInt32();
- }
- return status;
- }
-
- virtual status_t releaseSoundTriggerSession(audio_session_t session)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(session);
- status_t status = remote()->transact(RELEASE_SOUNDTRIGGER_SESSION, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return (status_t)reply.readInt32();
- }
-
- virtual audio_mode_t getPhoneState()
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = remote()->transact(GET_PHONE_STATE, data, &reply);
- if (status != NO_ERROR) {
- return AUDIO_MODE_INVALID;
- }
- return (audio_mode_t)reply.readInt32();
- }
-
- virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(registration ? 1 : 0);
- size_t size = mixes.size();
- if (size > MAX_MIXES_PER_POLICY) {
- size = MAX_MIXES_PER_POLICY;
- }
- size_t sizePosition = data.dataPosition();
- data.writeInt32(size);
- size_t finalSize = size;
- for (size_t i = 0; i < size; i++) {
- size_t position = data.dataPosition();
- if (mixes[i].writeToParcel(&data) != NO_ERROR) {
- data.setDataPosition(position);
- finalSize--;
- }
- }
- if (size != finalSize) {
- size_t position = data.dataPosition();
- data.setDataPosition(sizePosition);
- data.writeInt32(finalSize);
- data.setDataPosition(position);
- }
- status_t status = remote()->transact(REGISTER_POLICY_MIXES, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t)reply.readInt32();
- }
- return status;
- }
-
- virtual status_t startAudioSource(const struct audio_port_config *source,
- const audio_attributes_t *attributes,
- audio_port_handle_t *portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- if (source == NULL || attributes == NULL || portId == NULL) {
- return BAD_VALUE;
- }
- data.write(source, sizeof(struct audio_port_config));
- data.write(attributes, sizeof(audio_attributes_t));
- status_t status = remote()->transact(START_AUDIO_SOURCE, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = (status_t)reply.readInt32();
- if (status != NO_ERROR) {
- return status;
- }
- *portId = (audio_port_handle_t)reply.readInt32();
- return status;
- }
-
- virtual status_t stopAudioSource(audio_port_handle_t portId)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(portId);
- status_t status = remote()->transact(STOP_AUDIO_SOURCE, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = (status_t)reply.readInt32();
- return status;
- }
-
- virtual status_t setMasterMono(bool mono)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast<int32_t>(mono));
- status_t status = remote()->transact(SET_MASTER_MONO, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t getMasterMono(bool *mono)
- {
- if (mono == nullptr) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- status_t status = remote()->transact(GET_MASTER_MONO, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status == NO_ERROR) {
- *mono = static_cast<bool>(reply.readInt32());
- }
- return status;
- }
-
- virtual float getStreamVolumeDB(audio_stream_type_t stream, int index, audio_devices_t device)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast <int32_t>(stream));
- data.writeInt32(static_cast <int32_t>(index));
- data.writeUint32(static_cast <uint32_t>(device));
- status_t status = remote()->transact(GET_STREAM_VOLUME_DB, data, &reply);
- if (status != NO_ERROR) {
- return NAN;
- }
- return reply.readFloat();
- }
-
- virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
- audio_format_t *surroundFormats,
- bool *surroundFormatsEnabled,
- bool reported)
- {
- if (numSurroundFormats == NULL || (*numSurroundFormats != 0 &&
- (surroundFormats == NULL || surroundFormatsEnabled == NULL))) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- unsigned int numSurroundFormatsReq = *numSurroundFormats;
- data.writeUint32(numSurroundFormatsReq);
- data.writeBool(reported);
- status_t status = remote()->transact(GET_SURROUND_FORMATS, data, &reply);
- if (status == NO_ERROR && (status = (status_t)reply.readInt32()) == NO_ERROR) {
- *numSurroundFormats = reply.readUint32();
- }
- if (status == NO_ERROR) {
- if (numSurroundFormatsReq > *numSurroundFormats) {
- numSurroundFormatsReq = *numSurroundFormats;
- }
- if (numSurroundFormatsReq > 0) {
- status = reply.read(surroundFormats,
- numSurroundFormatsReq * sizeof(audio_format_t));
- if (status != NO_ERROR) {
- return status;
- }
- status = reply.read(surroundFormatsEnabled,
- numSurroundFormatsReq * sizeof(bool));
- }
- }
- return status;
- }
-
- virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(audioFormat);
- data.writeBool(enabled);
- status_t status = remote()->transact(SET_SURROUND_FORMAT_ENABLED, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return reply.readInt32();
- }
-
- virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
- std::vector<audio_format_t> *formats)
- {
- if (formats == NULL) {
- return BAD_VALUE;
- }
-
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = remote()->transact(GET_OFFLOAD_FORMATS_A2DP, data, &reply);
- if (status != NO_ERROR || (status = (status_t)reply.readInt32()) != NO_ERROR) {
- return status;
- }
-
- size_t list_size = reply.readUint32();
-
- for (size_t i = 0; i < list_size; i++) {
- formats->push_back(static_cast<audio_format_t>(reply.readInt32()));
- }
- return NO_ERROR;
- }
-
-
- virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_usage_t usage,
- audio_unique_id_t* id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(type, sizeof(effect_uuid_t));
- data.writeString16(opPackageName);
- data.write(uuid, sizeof(effect_uuid_t));
- data.writeInt32(priority);
- data.writeInt32((int32_t) usage);
- status_t status = remote()->transact(ADD_STREAM_DEFAULT_EFFECT, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- *id = reply.readInt32();
- return status;
- }
-
- virtual status_t removeStreamDefaultEffect(audio_unique_id_t id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(id);
- status_t status = remote()->transact(REMOVE_STREAM_DEFAULT_EFFECT, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_source_t source,
- audio_unique_id_t* id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.write(type, sizeof(effect_uuid_t));
- data.writeString16(opPackageName);
- data.write(uuid, sizeof(effect_uuid_t));
- data.writeInt32(priority);
- data.writeInt32((int32_t) source);
- status_t status = remote()->transact(ADD_SOURCE_DEFAULT_EFFECT, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast <status_t> (reply.readInt32());
- *id = reply.readInt32();
- return status;
- }
-
- virtual status_t removeSourceDefaultEffect(audio_unique_id_t id)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(id);
- status_t status = remote()->transact(REMOVE_SOURCE_DEFAULT_EFFECT, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setAssistantUid(uid_t uid)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(uid);
- status_t status = remote()->transact(SET_ASSISTANT_UID, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(uids.size());
- for (auto uid : uids) {
- data.writeInt32(uid);
- }
- status_t status = remote()->transact(SET_A11Y_SERVICES_UIDS, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual status_t setCurrentImeUid(uid_t uid)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(uid);
- status_t status = remote()->transact(SET_CURRENT_IME_UID, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast <status_t> (reply.readInt32());
- }
-
- virtual bool isHapticPlaybackSupported()
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = remote()->transact(IS_HAPTIC_PLAYBACK_SUPPORTED, data, &reply);
- if (status != NO_ERROR) {
- return false;
- }
- return reply.readBool();
- }
-
- virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- data.writeInt32((int32_t) uid);
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return status;
- }
-
- status = remote()->transact(SET_UID_DEVICE_AFFINITY, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t)reply.readInt32();
- }
- return status;
- }
-
- virtual status_t removeUidDeviceAffinities(uid_t uid) {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- data.writeInt32((int32_t) uid);
-
- status_t status =
- remote()->transact(REMOVE_UID_DEVICE_AFFINITY, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t) reply.readInt32();
- }
- return status;
- }
-
- virtual status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- data.writeInt32((int32_t) userId);
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return status;
- }
-
- status = remote()->transact(SET_USERID_DEVICE_AFFINITY, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t)reply.readInt32();
- }
- return status;
- }
-
- virtual status_t removeUserIdDeviceAffinities(int userId) {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- data.writeInt32((int32_t) userId);
-
- status_t status =
- remote()->transact(REMOVE_USERID_DEVICE_AFFINITY, data, &reply);
- if (status == NO_ERROR) {
- status = (status_t) reply.readInt32();
- }
- return status;
- }
-
- virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- status_t status = remote()->transact(LIST_AUDIO_PRODUCT_STRATEGIES, data, &reply);
- if (status != NO_ERROR) {
- ALOGE("%s: permission denied", __func__);
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- uint32_t numStrategies = static_cast<uint32_t>(reply.readInt32());
- for (size_t i = 0; i < numStrategies; i++) {
- AudioProductStrategy strategy;
- status = strategy.readFromParcel(&reply);
- if (status != NO_ERROR) {
- ALOGE("%s: failed to read strategies", __FUNCTION__);
- strategies.clear();
- return status;
- }
- strategies.push_back(strategy);
- }
- return NO_ERROR;
- }
-
- virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
- product_strategy_t &productStrategy)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = aa.writeToParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(GET_STRATEGY_FOR_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- productStrategy = static_cast<product_strategy_t>(reply.readInt32());
- return NO_ERROR;
- }
-
- virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
-
- status_t status = remote()->transact(LIST_AUDIO_VOLUME_GROUPS, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- uint32_t numGroups = static_cast<uint32_t>(reply.readInt32());
- for (size_t i = 0; i < numGroups; i++) {
- AudioVolumeGroup group;
- status = group.readFromParcel(&reply);
- if (status != NO_ERROR) {
- ALOGE("%s: failed to read volume groups", __FUNCTION__);
- groups.clear();
- return status;
- }
- groups.push_back(group);
- }
- return NO_ERROR;
- }
-
- virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
- volume_group_t &volumeGroup)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = aa.writeToParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(GET_VOLUME_GROUP_FOR_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status != NO_ERROR) {
- return status;
- }
- volumeGroup = static_cast<volume_group_t>(reply.readInt32());
- return NO_ERROR;
- }
-
- virtual status_t setRttEnabled(bool enabled)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeInt32(static_cast<int32_t>(enabled));
- status_t status = remote()->transact(SET_RTT_ENABLED, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual bool isCallScreenModeSupported()
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = remote()->transact(IS_CALL_SCREEN_MODE_SUPPORTED, data, &reply);
- if (status != NO_ERROR) {
- return false;
- }
- return reply.readBool();
- }
-
- virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role, const AudioDeviceTypeAddrVector &devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(strategy));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return BAD_VALUE;
- }
- status = remote()->transact(SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(strategy));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY,
- data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
- device_role_t role, AudioDeviceTypeAddrVector &devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(strategy));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY,
- data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = reply.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role, const AudioDeviceTypeAddrVector &devices) {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(audioSource));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(SET_DEVICES_ROLE_FOR_CAPTURE_PRESET, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role, const AudioDeviceTypeAddrVector &devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(audioSource));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET, data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t removeDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role,
- const AudioDeviceTypeAddrVector& devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(audioSource));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = data.writeParcelableVector(devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t clearDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(audioSource));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = remote()->transact(CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET,
- data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
- device_role_t role, AudioDeviceTypeAddrVector &devices)
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- data.writeUint32(static_cast<uint32_t>(audioSource));
- data.writeUint32(static_cast<uint32_t>(role));
- status_t status = remote()->transact(GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET,
- data, &reply);
- if (status != NO_ERROR) {
- return status;
- }
- status = reply.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- return static_cast<status_t>(reply.readInt32());
- }
-
- virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
- AudioDeviceTypeAddrVector *devices) const
- {
- if (devices == nullptr) {
- return BAD_VALUE;
- }
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- status_t status = aa.writeToParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
- status = remote()->transact(GET_DEVICES_FOR_ATTRIBUTES, data, &reply);
- if (status != NO_ERROR) {
- // transaction failed, return error
- return status;
- }
- status = static_cast<status_t>(reply.readInt32());
- if (status != NO_ERROR) {
- // APM method call failed, return error
- return status;
- }
-
- const size_t numberOfDevices = (size_t)reply.readInt32();
- for (size_t i = 0; i < numberOfDevices; i++) {
- AudioDeviceTypeAddr device;
- if (device.readFromParcel((Parcel*)&reply) == NO_ERROR) {
- devices->push_back(device);
- } else {
- return FAILED_TRANSACTION;
- }
- }
- return NO_ERROR;
- }
-
- virtual void onNewAudioModulesAvailable()
- {
- Parcel data, reply;
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- remote()->transact(AUDIO_MODULES_UPDATED, data, &reply, IBinder::FLAG_ONEWAY);
- }
-
- status_t registerSoundTriggerCaptureStateListener(
- const sp<media::ICaptureStateListener>& listener,
- bool* result) override {
- Parcel data, reply;
- status_t status;
- status =
- data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
- if (status != NO_ERROR) return status;
- status = data.writeStrongBinder(IInterface::asBinder(listener));
- if (status != NO_ERROR) return status;
- status =
- remote()->transact(REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER,
- data,
- &reply,
- 0);
- if (status != NO_ERROR) return status;
- status = reply.readBool(result);
- if (status != NO_ERROR) return status;
- return NO_ERROR;
- }
-};
-
-IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
-
-// ----------------------------------------------------------------------
-
-status_t BnAudioPolicyService::onTransact(
- uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
-{
- // make sure transactions reserved to AudioFlinger do not come from other processes
- switch (code) {
- case START_OUTPUT:
- case STOP_OUTPUT:
- case RELEASE_OUTPUT:
- case GET_INPUT_FOR_ATTR:
- case START_INPUT:
- case STOP_INPUT:
- case RELEASE_INPUT:
- case GET_OUTPUT_FOR_EFFECT:
- case REGISTER_EFFECT:
- case UNREGISTER_EFFECT:
- case SET_EFFECT_ENABLED:
- case GET_STRATEGY_FOR_STREAM:
- case GET_OUTPUT_FOR_ATTR:
- case MOVE_EFFECTS_TO_IO:
- ALOGW("%s: transaction %d received from PID %d",
- __func__, code, IPCThreadState::self()->getCallingPid());
- // return status only for non void methods
- switch (code) {
- case RELEASE_OUTPUT:
- case RELEASE_INPUT:
- break;
- default:
- reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
- break;
- }
- return OK;
- default:
- break;
- }
-
- // make sure the following transactions come from system components
- switch (code) {
- case SET_DEVICE_CONNECTION_STATE:
- case HANDLE_DEVICE_CONFIG_CHANGE:
- case SET_PHONE_STATE:
-//FIXME: Allow SET_FORCE_USE calls from system apps until a better use case routing API is available
-// case SET_FORCE_USE:
- case INIT_STREAM_VOLUME:
- case SET_STREAM_VOLUME:
- case SET_VOLUME_ATTRIBUTES:
- case GET_STREAM_VOLUME:
- case GET_VOLUME_ATTRIBUTES:
- case GET_MIN_VOLUME_FOR_ATTRIBUTES:
- case GET_MAX_VOLUME_FOR_ATTRIBUTES:
- case IS_STREAM_ACTIVE:
- case IS_STREAM_ACTIVE_REMOTELY:
- case IS_SOURCE_ACTIVE:
- case GET_DEVICES_FOR_STREAM:
- case REGISTER_POLICY_MIXES:
- case SET_MASTER_MONO:
- case GET_SURROUND_FORMATS:
- case SET_SURROUND_FORMAT_ENABLED:
- case SET_ASSISTANT_UID:
- case SET_A11Y_SERVICES_UIDS:
- case SET_UID_DEVICE_AFFINITY:
- case REMOVE_UID_DEVICE_AFFINITY:
- case SET_USERID_DEVICE_AFFINITY:
- case REMOVE_USERID_DEVICE_AFFINITY:
- case GET_OFFLOAD_FORMATS_A2DP:
- case LIST_AUDIO_VOLUME_GROUPS:
- case GET_VOLUME_GROUP_FOR_ATTRIBUTES:
- case ACQUIRE_SOUNDTRIGGER_SESSION:
- case RELEASE_SOUNDTRIGGER_SESSION:
- case SET_RTT_ENABLED:
- case IS_CALL_SCREEN_MODE_SUPPORTED:
- case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
- case SET_SUPPORTED_SYSTEM_USAGES:
- case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY:
- case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY:
- case GET_DEVICES_FOR_ATTRIBUTES:
- case SET_ALLOWED_CAPTURE_POLICY:
- case AUDIO_MODULES_UPDATED:
- case SET_CURRENT_IME_UID:
- case REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER:
- case SET_DEVICES_ROLE_FOR_CAPTURE_PRESET:
- case ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET:
- case REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET:
- case CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET:
- case GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET: {
- if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
- ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
- __func__, code, IPCThreadState::self()->getCallingPid(),
- IPCThreadState::self()->getCallingUid());
- reply->writeInt32(static_cast<int32_t> (INVALID_OPERATION));
- return OK;
- }
- } break;
- default:
- break;
- }
-
- std::string tag("IAudioPolicyService command " + std::to_string(code));
- TimeCheck check(tag.c_str());
-
- switch (code) {
- case SET_DEVICE_CONNECTION_STATE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_devices_t device =
- static_cast <audio_devices_t>(data.readInt32());
- audio_policy_dev_state_t state =
- static_cast <audio_policy_dev_state_t>(data.readInt32());
- const char *device_address = data.readCString();
- const char *device_name = data.readCString();
- audio_format_t codecFormat = static_cast <audio_format_t>(data.readInt32());
- if (device_address == nullptr || device_name == nullptr) {
- ALOGE("Bad Binder transaction: SET_DEVICE_CONNECTION_STATE for device %u", device);
- reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
- } else {
- reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device,
- state,
- device_address,
- device_name,
- codecFormat)));
- }
- return NO_ERROR;
- } break;
-
- case GET_DEVICE_CONNECTION_STATE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_devices_t device =
- static_cast<audio_devices_t> (data.readInt32());
- const char *device_address = data.readCString();
- if (device_address == nullptr) {
- ALOGE("Bad Binder transaction: GET_DEVICE_CONNECTION_STATE for device %u", device);
- reply->writeInt32(static_cast<int32_t> (AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
- } else {
- reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device,
- device_address)));
- }
- return NO_ERROR;
- } break;
-
- case HANDLE_DEVICE_CONFIG_CHANGE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_devices_t device =
- static_cast <audio_devices_t>(data.readInt32());
- const char *device_address = data.readCString();
- const char *device_name = data.readCString();
- audio_format_t codecFormat =
- static_cast <audio_format_t>(data.readInt32());
- if (device_address == nullptr || device_name == nullptr) {
- ALOGE("Bad Binder transaction: HANDLE_DEVICE_CONFIG_CHANGE for device %u", device);
- reply->writeInt32(static_cast<int32_t> (BAD_VALUE));
- } else {
- reply->writeInt32(static_cast<uint32_t> (handleDeviceConfigChange(device,
- device_address,
- device_name,
- codecFormat)));
- }
- return NO_ERROR;
- } break;
-
- case SET_PHONE_STATE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- reply->writeInt32(static_cast <uint32_t>(setPhoneState(
- (audio_mode_t) data.readInt32(),
- (uid_t) data.readInt32())));
- return NO_ERROR;
- } break;
-
- case SET_FORCE_USE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
- data.readInt32());
- audio_policy_forced_cfg_t config =
- static_cast <audio_policy_forced_cfg_t>(data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config)));
- return NO_ERROR;
- } break;
-
- case GET_FORCE_USE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(
- data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(getForceUse(usage)));
- return NO_ERROR;
- } break;
-
- case GET_OUTPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- audio_io_handle_t output = getOutput(stream);
- reply->writeInt32(static_cast <int>(output));
- return NO_ERROR;
- } break;
-
- case GET_OUTPUT_FOR_ATTR: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
- status_t status = data.read(&attr, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
- audio_session_t session = (audio_session_t)data.readInt32();
- audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
- bool hasStream = data.readInt32() != 0;
- if (hasStream) {
- stream = (audio_stream_type_t)data.readInt32();
- }
- pid_t pid = (pid_t)data.readInt32();
- uid_t uid = (uid_t)data.readInt32();
- audio_config_t config;
- memset(&config, 0, sizeof(audio_config_t));
- data.read(&config, sizeof(audio_config_t));
- audio_output_flags_t flags =
- static_cast <audio_output_flags_t>(data.readInt32());
- audio_port_handle_t selectedDeviceId = data.readInt32();
- audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
- audio_io_handle_t output = 0;
- std::vector<audio_io_handle_t> secondaryOutputs;
-
- status = AudioValidator::validateAudioAttributes(attr, "68953950");
- if (status != NO_ERROR) {
- reply->writeInt32(status);
- return NO_ERROR;
- }
- status = getOutputForAttr(&attr,
- &output, session, &stream, pid, uid,
- &config,
- flags, &selectedDeviceId, &portId, &secondaryOutputs);
- reply->writeInt32(status);
- status = reply->write(&attr, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
- reply->writeInt32(output);
- reply->writeInt32(stream);
- reply->writeInt32(selectedDeviceId);
- reply->writeInt32(portId);
- reply->writeInt32(secondaryOutputs.size());
- return reply->write(secondaryOutputs.data(),
- secondaryOutputs.size() * sizeof(audio_io_handle_t));
- } break;
-
- case START_OUTPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(startOutput(portId)));
- return NO_ERROR;
- } break;
-
- case STOP_OUTPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(stopOutput(portId)));
- return NO_ERROR;
- } break;
-
- case RELEASE_OUTPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- releaseOutput(portId);
- return NO_ERROR;
- } break;
-
- case GET_INPUT_FOR_ATTR: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attr = {};
- status_t status = data.read(&attr, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
-
- audio_io_handle_t input = (audio_io_handle_t)data.readInt32();
- audio_unique_id_t riid = (audio_unique_id_t)data.readInt32();
- audio_session_t session = (audio_session_t)data.readInt32();
- pid_t pid = (pid_t)data.readInt32();
- uid_t uid = (uid_t)data.readInt32();
- const String16 opPackageName = data.readString16();
- audio_config_base_t config;
- memset(&config, 0, sizeof(audio_config_base_t));
- data.read(&config, sizeof(audio_config_base_t));
- audio_input_flags_t flags = (audio_input_flags_t) data.readInt32();
- audio_port_handle_t selectedDeviceId = (audio_port_handle_t) data.readInt32();
- audio_port_handle_t portId = (audio_port_handle_t)data.readInt32();
-
- status = AudioValidator::validateAudioAttributes(attr, "68953950");
- if (status == NO_ERROR) {
- status = getInputForAttr(&attr, &input, riid, session, pid, uid,
- opPackageName, &config,
- flags, &selectedDeviceId, &portId);
- }
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- reply->writeInt32(input);
- reply->writeInt32(selectedDeviceId);
- reply->writeInt32(portId);
- }
- return NO_ERROR;
- } break;
-
- case START_INPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- status_t status = startInput(portId);
- reply->writeInt32(static_cast <uint32_t>(status));
- return NO_ERROR;
- } break;
-
- case STOP_INPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(stopInput(portId)));
- return NO_ERROR;
- } break;
-
- case RELEASE_INPUT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_port_handle_t portId = static_cast <audio_port_handle_t>(data.readInt32());
- releaseInput(portId);
- return NO_ERROR;
- } break;
-
- case INIT_STREAM_VOLUME: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- int indexMin = data.readInt32();
- int indexMax = data.readInt32();
- reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax)));
- return NO_ERROR;
- } break;
-
- case SET_STREAM_VOLUME: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- int index = data.readInt32();
- audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
- reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,
- index,
- device)));
- return NO_ERROR;
- } break;
-
- case GET_STREAM_VOLUME: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
- int index = 0;
- status_t status = getStreamVolumeIndex(stream, &index, device);
- reply->writeInt32(index);
- reply->writeInt32(static_cast <uint32_t>(status));
- return NO_ERROR;
- } break;
-
- case GET_STRATEGY_FOR_STREAM: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- reply->writeUint32(getStrategyForStream(stream));
- return NO_ERROR;
- } break;
-
- case SET_VOLUME_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attributes = {};
- status_t status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
-
- int index = data.readInt32();
- audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-
- status = AudioValidator::validateAudioAttributes(attributes, "169572641");
- if (status == NO_ERROR) {
- status = setVolumeIndexForAttributes(attributes, index, device);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- } break;
-
- case GET_VOLUME_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attributes = {};
- status_t status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
- audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());
-
- int index = 0;
- status = AudioValidator::validateAudioAttributes(attributes, "169572641");
- if (status == NO_ERROR) {
- status = getVolumeIndexForAttributes(attributes, index, device);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- if (status == NO_ERROR) {
- reply->writeInt32(index);
- }
- return NO_ERROR;
- } break;
-
- case GET_MIN_VOLUME_FOR_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attributes = {};
- status_t status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
-
- int index = 0;
- status = AudioValidator::validateAudioAttributes(attributes, "169572641");
- if (status == NO_ERROR) {
- status = getMinVolumeIndexForAttributes(attributes, index);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- if (status == NO_ERROR) {
- reply->writeInt32(index);
- }
- return NO_ERROR;
- } break;
-
- case GET_MAX_VOLUME_FOR_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_attributes_t attributes = {};
- status_t status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
-
- int index = 0;
- status = AudioValidator::validateAudioAttributes(attributes, "169572641");
- if (status == NO_ERROR) {
- status = getMaxVolumeIndexForAttributes(attributes, index);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- if (status == NO_ERROR) {
- reply->writeInt32(index);
- }
- return NO_ERROR;
- } break;
-
- case GET_DEVICES_FOR_STREAM: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- reply->writeInt32(static_cast <int>(getDevicesForStream(stream)));
- return NO_ERROR;
- } break;
-
- case GET_OUTPUT_FOR_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- effect_descriptor_t desc = {};
- status_t status = data.read(&desc, sizeof(desc));
- if (status != NO_ERROR) {
- android_errorWriteLog(0x534e4554, "73126106");
- return status;
- }
- status = AudioValidator::validateEffectDescriptor(desc, "73126106");
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- audio_io_handle_t output = getOutputForEffect(&desc);
- reply->writeInt32(static_cast <int32_t>(output));
- }
- return NO_ERROR;
- } break;
-
- case REGISTER_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- effect_descriptor_t desc = {};
- status_t status = data.read(&desc, sizeof(desc));
- if (status != NO_ERROR) {
- android_errorWriteLog(0x534e4554, "73126106");
- return status;
- }
- audio_io_handle_t io = data.readInt32();
- uint32_t strategy = data.readInt32();
- audio_session_t session = (audio_session_t) data.readInt32();
- int id = data.readInt32();
- status = AudioValidator::validateEffectDescriptor(desc, "73126106");
- if (status == NO_ERROR) {
- status = registerEffect(&desc, io, strategy, session, id);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- } break;
-
- case UNREGISTER_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- int id = data.readInt32();
- reply->writeInt32(static_cast <int32_t>(unregisterEffect(id)));
- return NO_ERROR;
- } break;
-
- case SET_EFFECT_ENABLED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- int id = data.readInt32();
- bool enabled = static_cast <bool>(data.readInt32());
- reply->writeInt32(static_cast <int32_t>(setEffectEnabled(id, enabled)));
- return NO_ERROR;
- } break;
-
- case MOVE_EFFECTS_TO_IO: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- std::vector<int> ids;
- int32_t size;
- status_t status = data.readInt32(&size);
- if (status != NO_ERROR) {
- return status;
- }
- if (size > MAX_ITEMS_PER_LIST) {
- return BAD_VALUE;
- }
- for (int32_t i = 0; i < size; i++) {
- int id;
- status = data.readInt32(&id);
- if (status != NO_ERROR) {
- return status;
- }
- ids.push_back(id);
- }
-
- audio_io_handle_t io = data.readInt32();
- reply->writeInt32(static_cast <int32_t>(moveEffectsToIo(ids, io)));
- return NO_ERROR;
- } break;
-
- case IS_STREAM_ACTIVE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
- uint32_t inPastMs = (uint32_t)data.readInt32();
- reply->writeInt32( isStreamActive(stream, inPastMs) );
- return NO_ERROR;
- } break;
-
- case IS_STREAM_ACTIVE_REMOTELY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream = (audio_stream_type_t) data.readInt32();
- uint32_t inPastMs = (uint32_t)data.readInt32();
- reply->writeInt32( isStreamActiveRemotely(stream, inPastMs) );
- return NO_ERROR;
- } break;
-
- case IS_SOURCE_ACTIVE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t source = (audio_source_t) data.readInt32();
- reply->writeInt32( isSourceActive(source));
- return NO_ERROR;
- }
-
- case QUERY_DEFAULT_PRE_PROCESSING: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_session_t audioSession = (audio_session_t) data.readInt32();
- uint32_t count = data.readInt32();
- if (count > AudioEffect::kMaxPreProcessing) {
- count = AudioEffect::kMaxPreProcessing;
- }
- uint32_t retCount = count;
- effect_descriptor_t *descriptors = new effect_descriptor_t[count]{};
- status_t status = queryDefaultPreProcessing(audioSession, descriptors, &retCount);
- reply->writeInt32(status);
- if (status != NO_ERROR && status != NO_MEMORY) {
- retCount = 0;
- }
- reply->writeInt32(retCount);
- if (retCount != 0) {
- if (retCount < count) {
- count = retCount;
- }
- reply->write(descriptors, sizeof(effect_descriptor_t) * count);
- }
- delete[] descriptors;
- return status;
- }
-
- case GET_OFFLOAD_MODE_SUPPORTED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_offload_info_t info = {};
- data.read(&info, sizeof(audio_offload_info_t));
- reply->writeInt32(static_cast<int32_t>(getOffloadSupport(info)));
- return NO_ERROR;
- }
-
- case IS_DIRECT_OUTPUT_SUPPORTED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_config_base_t config = {};
- audio_attributes_t attributes = {};
- status_t status = data.read(&config, sizeof(audio_config_base_t));
- if (status != NO_ERROR) return status;
- status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) return status;
- status = AudioValidator::validateAudioAttributes(attributes, "169572641");
- if (status == NO_ERROR) {
- status = isDirectOutputSupported(config, attributes);
- }
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- }
-
- case LIST_AUDIO_PORTS: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_port_role_t role = (audio_port_role_t)data.readInt32();
- audio_port_type_t type = (audio_port_type_t)data.readInt32();
- unsigned int numPortsReq = data.readInt32();
- if (numPortsReq > MAX_ITEMS_PER_LIST) {
- numPortsReq = MAX_ITEMS_PER_LIST;
- }
- unsigned int numPorts = numPortsReq;
- struct audio_port_v7 *ports =
- (struct audio_port_v7 *)calloc(numPortsReq, sizeof(struct audio_port_v7));
- if (ports == NULL) {
- reply->writeInt32(NO_MEMORY);
- reply->writeInt32(0);
- return NO_ERROR;
- }
- unsigned int generation;
- status_t status = listAudioPorts(role, type, &numPorts, ports, &generation);
- reply->writeInt32(status);
- reply->writeInt32(numPorts);
-
- if (status == NO_ERROR) {
- if (numPortsReq > numPorts) {
- numPortsReq = numPorts;
- }
- reply->write(ports, numPortsReq * sizeof(struct audio_port_v7));
- reply->writeInt32(generation);
- }
- free(ports);
- return NO_ERROR;
- }
-
- case GET_AUDIO_PORT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- struct audio_port_v7 port = {};
- status_t status = data.read(&port, sizeof(struct audio_port_v7));
- if (status != NO_ERROR) {
- ALOGE("b/23912202");
- return status;
- }
- status = AudioValidator::validateAudioPort(port);
- if (status == NO_ERROR) {
- status = getAudioPort(&port);
- }
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- reply->write(&port, sizeof(struct audio_port_v7));
- }
- return NO_ERROR;
- }
-
- case CREATE_AUDIO_PATCH: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- struct audio_patch patch = {};
- status_t status = data.read(&patch, sizeof(struct audio_patch));
- if (status != NO_ERROR) {
- return status;
- }
- audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
- status = data.read(&handle, sizeof(audio_patch_handle_t));
- if (status != NO_ERROR) {
- ALOGE("b/23912202");
- return status;
- }
- status = AudioValidator::validateAudioPatch(patch);
- if (status == NO_ERROR) {
- status = createAudioPatch(&patch, &handle);
- }
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- reply->write(&handle, sizeof(audio_patch_handle_t));
- }
- return NO_ERROR;
- }
-
- case RELEASE_AUDIO_PATCH: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
- data.read(&handle, sizeof(audio_patch_handle_t));
- status_t status = releaseAudioPatch(handle);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case LIST_AUDIO_PATCHES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- unsigned int numPatchesReq = data.readInt32();
- if (numPatchesReq > MAX_ITEMS_PER_LIST) {
- numPatchesReq = MAX_ITEMS_PER_LIST;
- }
- unsigned int numPatches = numPatchesReq;
- struct audio_patch *patches =
- (struct audio_patch *)calloc(numPatchesReq,
- sizeof(struct audio_patch));
- if (patches == NULL) {
- reply->writeInt32(NO_MEMORY);
- reply->writeInt32(0);
- return NO_ERROR;
- }
- unsigned int generation;
- status_t status = listAudioPatches(&numPatches, patches, &generation);
- reply->writeInt32(status);
- reply->writeInt32(numPatches);
- if (status == NO_ERROR) {
- if (numPatchesReq > numPatches) {
- numPatchesReq = numPatches;
- }
- reply->write(patches, numPatchesReq * sizeof(struct audio_patch));
- reply->writeInt32(generation);
- }
- free(patches);
- return NO_ERROR;
- }
-
- case SET_AUDIO_PORT_CONFIG: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- struct audio_port_config config = {};
- status_t status = data.read(&config, sizeof(struct audio_port_config));
- if (status != NO_ERROR) {
- return status;
- }
- status = AudioValidator::validateAudioPortConfig(config);
- if (status == NO_ERROR) {
- status = setAudioPortConfig(&config);
- }
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case REGISTER_CLIENT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- sp<media::IAudioPolicyServiceClient> client =
- interface_cast<media::IAudioPolicyServiceClient>(data.readStrongBinder());
- registerClient(client);
- return NO_ERROR;
- } break;
-
- case SET_AUDIO_PORT_CALLBACK_ENABLED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- setAudioPortCallbacksEnabled(data.readInt32() == 1);
- return NO_ERROR;
- } break;
-
- case SET_AUDIO_VOLUME_GROUP_CALLBACK_ENABLED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- setAudioVolumeGroupCallbacksEnabled(data.readInt32() == 1);
- return NO_ERROR;
- } break;
-
- case ACQUIRE_SOUNDTRIGGER_SESSION: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_session_t session = AUDIO_SESSION_NONE;
- audio_io_handle_t ioHandle = AUDIO_IO_HANDLE_NONE;
- audio_devices_t device = AUDIO_DEVICE_NONE;
- status_t status = acquireSoundTriggerSession(&session, &ioHandle, &device);
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- reply->writeInt32(session);
- reply->writeInt32(ioHandle);
- reply->writeInt32(device);
- }
- return NO_ERROR;
- } break;
-
- case RELEASE_SOUNDTRIGGER_SESSION: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_session_t session = (audio_session_t)data.readInt32();
- status_t status = releaseSoundTriggerSession(session);
- reply->writeInt32(status);
- return NO_ERROR;
- } break;
-
- case GET_PHONE_STATE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- reply->writeInt32((int32_t)getPhoneState());
- return NO_ERROR;
- } break;
-
- case REGISTER_POLICY_MIXES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool registration = data.readInt32() == 1;
- Vector<AudioMix> mixes;
- size_t size = (size_t)data.readInt32();
- if (size > MAX_MIXES_PER_POLICY) {
- size = MAX_MIXES_PER_POLICY;
- }
- for (size_t i = 0; i < size; i++) {
- AudioMix mix;
- if (mix.readFromParcel((Parcel*)&data) == NO_ERROR) {
- mixes.add(mix);
- }
- }
- status_t status = registerPolicyMixes(mixes, registration);
- reply->writeInt32(status);
- return NO_ERROR;
- } break;
-
- case START_AUDIO_SOURCE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- struct audio_port_config source = {};
- status_t status = data.read(&source, sizeof(struct audio_port_config));
- if (status != NO_ERROR) {
- return status;
- }
- audio_attributes_t attributes = {};
- status = data.read(&attributes, sizeof(audio_attributes_t));
- if (status != NO_ERROR) {
- return status;
- }
- status = AudioValidator::validateAudioPortConfig(source);
- if (status == NO_ERROR) {
- // OK to not always sanitize attributes as startAudioSource() is not called if
- // the port config is invalid.
- status = AudioValidator::validateAudioAttributes(attributes, "68953950");
- }
- audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
- if (status == NO_ERROR) {
- status = startAudioSource(&source, &attributes, &portId);
- }
- reply->writeInt32(status);
- reply->writeInt32(portId);
- return NO_ERROR;
- } break;
-
- case STOP_AUDIO_SOURCE: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_port_handle_t portId = (audio_port_handle_t) data.readInt32();
- status_t status = stopAudioSource(portId);
- reply->writeInt32(status);
- return NO_ERROR;
- } break;
-
- case SET_MASTER_MONO: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool mono = static_cast<bool>(data.readInt32());
- status_t status = setMasterMono(mono);
- reply->writeInt32(status);
- return NO_ERROR;
- } break;
-
- case GET_MASTER_MONO: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool mono;
- status_t status = getMasterMono(&mono);
- reply->writeInt32(status);
- if (status == NO_ERROR) {
- reply->writeInt32(static_cast<int32_t>(mono));
- }
- return NO_ERROR;
- } break;
-
- case GET_STREAM_VOLUME_DB: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_stream_type_t stream =
- static_cast <audio_stream_type_t>(data.readInt32());
- int index = static_cast <int>(data.readInt32());
- audio_devices_t device =
- static_cast <audio_devices_t>(data.readUint32());
- reply->writeFloat(getStreamVolumeDB(stream, index, device));
- return NO_ERROR;
- }
-
- case GET_SURROUND_FORMATS: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- unsigned int numSurroundFormatsReq = data.readUint32();
- if (numSurroundFormatsReq > MAX_ITEMS_PER_LIST) {
- numSurroundFormatsReq = MAX_ITEMS_PER_LIST;
- }
- bool reported = data.readBool();
- unsigned int numSurroundFormats = numSurroundFormatsReq;
- audio_format_t *surroundFormats = (audio_format_t *)calloc(
- numSurroundFormats, sizeof(audio_format_t));
- bool *surroundFormatsEnabled = (bool *)calloc(numSurroundFormats, sizeof(bool));
- if (numSurroundFormatsReq > 0 &&
- (surroundFormats == NULL || surroundFormatsEnabled == NULL)) {
- free(surroundFormats);
- free(surroundFormatsEnabled);
- reply->writeInt32(NO_MEMORY);
- return NO_ERROR;
- }
- status_t status = getSurroundFormats(
- &numSurroundFormats, surroundFormats, surroundFormatsEnabled, reported);
- reply->writeInt32(status);
-
- if (status == NO_ERROR) {
- reply->writeUint32(numSurroundFormats);
- if (numSurroundFormatsReq > numSurroundFormats) {
- numSurroundFormatsReq = numSurroundFormats;
- }
- reply->write(surroundFormats, numSurroundFormatsReq * sizeof(audio_format_t));
- reply->write(surroundFormatsEnabled, numSurroundFormatsReq * sizeof(bool));
- }
- free(surroundFormats);
- free(surroundFormatsEnabled);
- return NO_ERROR;
- }
-
- case SET_SURROUND_FORMAT_ENABLED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_format_t audioFormat = (audio_format_t) data.readInt32();
- bool enabled = data.readBool();
- status_t status = setSurroundFormatEnabled(audioFormat, enabled);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case GET_OFFLOAD_FORMATS_A2DP: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- std::vector<audio_format_t> encodingFormats;
- status_t status = getHwOffloadEncodingFormatsSupportedForA2DP(&encodingFormats);
- reply->writeInt32(status);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
- reply->writeUint32(static_cast<uint32_t>(encodingFormats.size()));
- for (size_t i = 0; i < encodingFormats.size(); i++)
- reply->writeInt32(static_cast<int32_t>(encodingFormats[i]));
- return NO_ERROR;
- }
-
-
- case ADD_STREAM_DEFAULT_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- effect_uuid_t type;
- status_t status = data.read(&type, sizeof(effect_uuid_t));
- if (status != NO_ERROR) {
- return status;
- }
- String16 opPackageName;
- status = data.readString16(&opPackageName);
- if (status != NO_ERROR) {
- return status;
- }
- effect_uuid_t uuid;
- status = data.read(&uuid, sizeof(effect_uuid_t));
- if (status != NO_ERROR) {
- return status;
- }
- int32_t priority = data.readInt32();
- audio_usage_t usage = (audio_usage_t) data.readInt32();
- audio_unique_id_t id = 0;
- reply->writeInt32(static_cast <int32_t>(addStreamDefaultEffect(&type,
- opPackageName,
- &uuid,
- priority,
- usage,
- &id)));
- reply->writeInt32(id);
- return NO_ERROR;
- }
-
- case REMOVE_STREAM_DEFAULT_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
- reply->writeInt32(static_cast <int32_t>(removeStreamDefaultEffect(id)));
- return NO_ERROR;
- }
-
- case ADD_SOURCE_DEFAULT_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- effect_uuid_t type;
- status_t status = data.read(&type, sizeof(effect_uuid_t));
- if (status != NO_ERROR) {
- return status;
- }
- String16 opPackageName;
- status = data.readString16(&opPackageName);
- if (status != NO_ERROR) {
- return status;
- }
- effect_uuid_t uuid;
- status = data.read(&uuid, sizeof(effect_uuid_t));
- if (status != NO_ERROR) {
- return status;
- }
- int32_t priority = data.readInt32();
- audio_source_t source = (audio_source_t) data.readInt32();
- audio_unique_id_t id = 0;
- reply->writeInt32(static_cast <int32_t>(addSourceDefaultEffect(&type,
- opPackageName,
- &uuid,
- priority,
- source,
- &id)));
- reply->writeInt32(id);
- return NO_ERROR;
- }
-
- case REMOVE_SOURCE_DEFAULT_EFFECT: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_unique_id_t id = static_cast<audio_unique_id_t>(data.readInt32());
- reply->writeInt32(static_cast <int32_t>(removeSourceDefaultEffect(id)));
- return NO_ERROR;
- }
-
- case SET_ASSISTANT_UID: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- int32_t uid;
- status_t status = data.readInt32(&uid);
- if (status != NO_ERROR) {
- return status;
- }
- status = setAssistantUid(uid);
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- }
-
- case SET_A11Y_SERVICES_UIDS: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- std::vector<uid_t> uids;
- int32_t size;
- status_t status = data.readInt32(&size);
- if (status != NO_ERROR) {
- return status;
- }
- if (size > MAX_ITEMS_PER_LIST) {
- size = MAX_ITEMS_PER_LIST;
- }
- for (int32_t i = 0; i < size; i++) {
- int32_t uid;
- status = data.readInt32(&uid);
- if (status != NO_ERROR) {
- return status;
- }
- uids.push_back(uid);
- }
- status = setA11yServicesUids(uids);
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- }
-
- case IS_HAPTIC_PLAYBACK_SUPPORTED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool isSupported = isHapticPlaybackSupported();
- reply->writeBool(isSupported);
- return NO_ERROR;
- }
- case SET_UID_DEVICE_AFFINITY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const uid_t uid = (uid_t) data.readInt32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = setUidDeviceAffinities(uid, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case REMOVE_UID_DEVICE_AFFINITY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const uid_t uid = (uid_t) data.readInt32();
- status_t status = removeUidDeviceAffinities(uid);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case SET_USERID_DEVICE_AFFINITY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const int userId = (int) data.readInt32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = setUserIdDeviceAffinities(userId, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case REMOVE_USERID_DEVICE_AFFINITY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- const int userId = (int) data.readInt32();
- status_t status = removeUserIdDeviceAffinities(userId);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case LIST_AUDIO_PRODUCT_STRATEGIES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- AudioProductStrategyVector strategies;
- status_t status = listAudioProductStrategies(strategies);
- reply->writeInt32(status);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
- size_t size = strategies.size();
- size_t sizePosition = reply->dataPosition();
- reply->writeInt32(size);
- size_t finalSize = size;
- for (size_t i = 0; i < size; i++) {
- size_t position = reply->dataPosition();
- if (strategies[i].writeToParcel(reply) != NO_ERROR) {
- reply->setDataPosition(position);
- finalSize--;
- }
- }
- if (size != finalSize) {
- size_t position = reply->dataPosition();
- reply->setDataPosition(sizePosition);
- reply->writeInt32(finalSize);
- reply->setDataPosition(position);
- }
- return NO_ERROR;
- }
-
- case GET_STRATEGY_FOR_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- AudioAttributes attributes;
- status_t status = attributes.readFromParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
- product_strategy_t strategy;
- status = getProductStrategyFromAudioAttributes(attributes, strategy);
- reply->writeInt32(status);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
- reply->writeUint32(static_cast<int>(strategy));
- return NO_ERROR;
- }
-
- case LIST_AUDIO_VOLUME_GROUPS: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- AudioVolumeGroupVector groups;
- status_t status = listAudioVolumeGroups(groups);
- reply->writeInt32(status);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
- size_t size = groups.size();
- size_t sizePosition = reply->dataPosition();
- reply->writeInt32(size);
- size_t finalSize = size;
- for (size_t i = 0; i < size; i++) {
- size_t position = reply->dataPosition();
- if (groups[i].writeToParcel(reply) != NO_ERROR) {
- reply->setDataPosition(position);
- finalSize--;
- }
- }
- if (size != finalSize) {
- size_t position = reply->dataPosition();
- reply->setDataPosition(sizePosition);
- reply->writeInt32(finalSize);
- reply->setDataPosition(position);
- }
- return NO_ERROR;
- }
-
- case GET_VOLUME_GROUP_FOR_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- AudioAttributes attributes;
- status_t status = attributes.readFromParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
-
- volume_group_t group;
- status = getVolumeGroupFromAudioAttributes(attributes, group);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
-
- reply->writeInt32(status);
- reply->writeUint32(static_cast<int>(group));
- return NO_ERROR;
- }
-
- case SET_SUPPORTED_SYSTEM_USAGES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- std::vector<audio_usage_t> systemUsages;
-
- int32_t size;
- status_t status = data.readInt32(&size);
- if (status != NO_ERROR) {
- return status;
- }
- if (size > MAX_ITEMS_PER_LIST) {
- size = MAX_ITEMS_PER_LIST;
- }
-
- for (int32_t i = 0; i < size; i++) {
- int32_t systemUsageInt;
- status = data.readInt32(&systemUsageInt);
- if (status != NO_ERROR) {
- return status;
- }
-
- audio_usage_t systemUsage = static_cast<audio_usage_t>(systemUsageInt);
- systemUsages.push_back(systemUsage);
- }
- status = setSupportedSystemUsages(systemUsages);
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- }
-
- case SET_ALLOWED_CAPTURE_POLICY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- uid_t uid = data.readInt32();
- audio_flags_mask_t flags = static_cast<audio_flags_mask_t>(data.readInt32());
- status_t status = setAllowedCapturePolicy(uid, flags);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case SET_RTT_ENABLED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool enabled = static_cast<bool>(data.readInt32());
- status_t status = setRttEnabled(enabled);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case IS_CALL_SCREEN_MODE_SUPPORTED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- bool isAvailable = isCallScreenModeSupported();
- reply->writeBool(isAvailable);
- return NO_ERROR;
- }
-
- case SET_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- product_strategy_t strategy = (product_strategy_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = setDevicesRoleForStrategy(strategy, role, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case REMOVE_DEVICES_ROLE_FOR_PRODUCT_STRATEGY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- product_strategy_t strategy = (product_strategy_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- status_t status = removeDevicesRoleForStrategy(strategy, role);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case GET_DEVICES_FOR_ROLE_AND_PRODUCT_STRATEGY: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- product_strategy_t strategy = (product_strategy_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = getDevicesForRoleAndStrategy(strategy, role, devices);
- status_t marshall_status = reply->writeParcelableVector(devices);
- if (marshall_status != NO_ERROR) {
- return marshall_status;
- }
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case GET_DEVICES_FOR_ATTRIBUTES: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- AudioAttributes attributes;
- status_t status = attributes.readFromParcel(&data);
- if (status != NO_ERROR) {
- return status;
- }
- AudioDeviceTypeAddrVector devices;
- status = getDevicesForAttributes(attributes.getAttributes(), &devices);
- // reply data formatted as:
- // - (int32) method call result from APM
- // - (int32) number of devices (n) if method call returned NO_ERROR
- // - n AudioDeviceTypeAddr if method call returned NO_ERROR
- reply->writeInt32(status);
- if (status != NO_ERROR) {
- return NO_ERROR;
- }
- status = reply->writeInt32(devices.size());
- if (status != NO_ERROR) {
- return status;
- }
- for (const auto& device : devices) {
- status = device.writeToParcel(reply);
- if (status != NO_ERROR) {
- return status;
- }
- }
-
- return NO_ERROR;
- }
-
- case AUDIO_MODULES_UPDATED: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- onNewAudioModulesAvailable();
- return NO_ERROR;
- } break;
-
- case SET_CURRENT_IME_UID: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- int32_t uid;
- status_t status = data.readInt32(&uid);
- if (status != NO_ERROR) {
- return status;
- }
- status = setCurrentImeUid(uid);
- reply->writeInt32(static_cast <int32_t>(status));
- return NO_ERROR;
- }
-
- case REGISTER_SOUNDTRIGGER_CAPTURE_STATE_LISTENER: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- sp<IBinder> binder = data.readStrongBinder();
- if (binder == nullptr) {
- return BAD_VALUE;
- }
- sp<ICaptureStateListener>
- listener = interface_cast<ICaptureStateListener>(
- binder);
- if (listener == nullptr) {
- return BAD_VALUE;
- }
- bool ret;
- status_t status =
- registerSoundTriggerCaptureStateListener(listener, &ret);
- LOG_ALWAYS_FATAL_IF(status != NO_ERROR,
- "Server returned unexpected status code: %d",
- status);
- status = reply->writeBool(ret);
- if (status != NO_ERROR) {
- return status;
- }
- return NO_ERROR;
- } break;
-
- case SET_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t audioSource = (audio_source_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = setDevicesRoleForCapturePreset(audioSource, role, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case ADD_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t audioSource = (audio_source_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = addDevicesRoleForCapturePreset(audioSource, role, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case REMOVE_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t audioSource = (audio_source_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = data.readParcelableVector(&devices);
- if (status != NO_ERROR) {
- return status;
- }
- status = removeDevicesRoleForCapturePreset(audioSource, role, devices);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case CLEAR_DEVICES_ROLE_FOR_CAPTURE_PRESET: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t audioSource = (audio_source_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- status_t status = clearDevicesRoleForCapturePreset(audioSource, role);
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- case GET_DEVICES_FOR_ROLE_AND_CAPTURE_PRESET: {
- CHECK_INTERFACE(IAudioPolicyService, data, reply);
- audio_source_t audioSource = (audio_source_t) data.readUint32();
- device_role_t role = (device_role_t) data.readUint32();
- AudioDeviceTypeAddrVector devices;
- status_t status = getDevicesForRoleAndCapturePreset(audioSource, role, devices);
- status_t marshall_status = reply->writeParcelableVector(devices);
- if (marshall_status != NO_ERROR) {
- return marshall_status;
- }
- reply->writeInt32(status);
- return NO_ERROR;
- }
-
- default:
- return BBinder::onTransact(code, data, reply, flags);
- }
-}
-
-// ----------------------------------------------------------------------------
-
-} // namespace android
diff --git a/media/libaudioclient/PolicyAidlConversion.cpp b/media/libaudioclient/PolicyAidlConversion.cpp
new file mode 100644
index 0000000..25fdb49
--- /dev/null
+++ b/media/libaudioclient/PolicyAidlConversion.cpp
@@ -0,0 +1,469 @@
+/*
+ * Copyright (C) 2021 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 "PolicyAidlConversion"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include "media/PolicyAidlConversion.h"
+
+#include "media/AidlConversion.h"
+
+namespace android {
+
+using base::unexpected;
+
+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);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixType_uint32_t(media::AudioMixType aidl) {
+ switch (aidl) {
+ case media::AudioMixType::PLAYERS:
+ return MIX_TYPE_PLAYERS;
+ case media::AudioMixType::RECORDERS:
+ return MIX_TYPE_RECORDERS;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixType>
+legacy2aidl_uint32_t_AudioMixType(uint32_t legacy) {
+ switch (legacy) {
+ case MIX_TYPE_PLAYERS:
+ return media::AudioMixType::PLAYERS;
+ case MIX_TYPE_RECORDERS:
+ return media::AudioMixType::RECORDERS;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t(media::AudioMixCallbackFlag aidl) {
+ switch (aidl) {
+ case media::AudioMixCallbackFlag::NOTIFY_ACTIVITY:
+ return AudioMix::kCbFlagNotifyActivity;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixCallbackFlag>
+legacy2aidl_uint32_t_AudioMixCallbackFlag(uint32_t legacy) {
+ switch (legacy) {
+ case AudioMix::kCbFlagNotifyActivity:
+ return media::AudioMixCallbackFlag::NOTIFY_ACTIVITY;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(int32_t aidl) {
+ return convertBitmask<uint32_t, int32_t, uint32_t, media::AudioMixCallbackFlag>(
+ aidl,
+ aidl2legacy_AudioMixCallbackFlag_uint32_t,
+ indexToEnum_index<media::AudioMixCallbackFlag>,
+ enumToMask_bitmask<uint32_t, uint32_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(uint32_t legacy) {
+ return convertBitmask<int32_t, uint32_t, media::AudioMixCallbackFlag, uint32_t>(
+ legacy,
+ legacy2aidl_uint32_t_AudioMixCallbackFlag,
+ indexToEnum_bitmask<uint32_t>,
+ enumToMask_index<int32_t, media::AudioMixCallbackFlag>);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t(media::AudioMixRouteFlag aidl) {
+ switch (aidl) {
+ case media::AudioMixRouteFlag::RENDER:
+ return MIX_ROUTE_FLAG_RENDER;
+ case media::AudioMixRouteFlag::LOOP_BACK:
+ return MIX_ROUTE_FLAG_LOOP_BACK;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixRouteFlag>
+legacy2aidl_uint32_t_AudioMixRouteFlag(uint32_t legacy) {
+ switch (legacy) {
+ case MIX_ROUTE_FLAG_RENDER:
+ return media::AudioMixRouteFlag::RENDER;
+ case MIX_ROUTE_FLAG_LOOP_BACK:
+ return media::AudioMixRouteFlag::LOOP_BACK;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t_mask(int32_t aidl) {
+ return convertBitmask<uint32_t, int32_t, uint32_t, media::AudioMixRouteFlag>(
+ aidl,
+ aidl2legacy_AudioMixRouteFlag_uint32_t,
+ indexToEnum_index<media::AudioMixRouteFlag>,
+ enumToMask_bitmask<uint32_t, uint32_t>);
+}
+
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixRouteFlag_mask(uint32_t legacy) {
+ return convertBitmask<int32_t, uint32_t, media::AudioMixRouteFlag, uint32_t>(
+ legacy,
+ legacy2aidl_uint32_t_AudioMixRouteFlag,
+ indexToEnum_bitmask<uint32_t>,
+ enumToMask_index<int32_t, media::AudioMixRouteFlag>);
+}
+
+// This type is unnamed in the original definition, thus we name it here.
+using AudioMixMatchCriterionValue = decltype(AudioMixMatchCriterion::mValue);
+
+ConversionResult<AudioMixMatchCriterionValue>
+aidl2legacy_AudioMixMatchCriterionValue(
+ const media::AudioMixMatchCriterionValue& aidl,
+ uint32_t* rule) {
+ AudioMixMatchCriterionValue legacy;
+ *rule = 0;
+ switch (aidl.getTag()) {
+ case media::AudioMixMatchCriterionValue::usage:
+ legacy.mUsage = VALUE_OR_RETURN(
+ aidl2legacy_AudioUsage_audio_usage_t(UNION_GET(aidl, usage).value()));
+ *rule |= RULE_MATCH_ATTRIBUTE_USAGE;
+ return legacy;
+
+ case media::AudioMixMatchCriterionValue::source:
+ legacy.mSource = VALUE_OR_RETURN(
+ aidl2legacy_AudioSourceType_audio_source_t(UNION_GET(aidl, source).value()));
+ *rule |= RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET;
+ return legacy;
+
+ case media::AudioMixMatchCriterionValue::uid:
+ legacy.mUid = VALUE_OR_RETURN(
+ aidl2legacy_int32_t_uid_t(UNION_GET(aidl, uid).value()));
+ *rule |= RULE_MATCH_UID;
+ return legacy;
+
+ case media::AudioMixMatchCriterionValue::userId:
+ legacy.mUserId = VALUE_OR_RETURN(
+ convertIntegral<int>(UNION_GET(aidl, userId).value()));
+ *rule |= RULE_MATCH_USERID;
+ return legacy;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioMixMatchCriterionValue>
+legacy2aidl_AudioMixMatchCriterionValue(
+ const AudioMixMatchCriterionValue& legacy,
+ uint32_t rule) {
+ media::AudioMixMatchCriterionValue aidl;
+ switch (rule) {
+ case RULE_MATCH_ATTRIBUTE_USAGE:
+ UNION_SET(aidl, usage,
+ VALUE_OR_RETURN(legacy2aidl_audio_usage_t_AudioUsage(legacy.mUsage)));
+ break;
+
+ case RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET:
+ UNION_SET(aidl, source,
+ VALUE_OR_RETURN(legacy2aidl_audio_source_t_AudioSourceType(legacy.mSource)));
+ break;
+
+ case RULE_MATCH_UID:
+ UNION_SET(aidl, uid, VALUE_OR_RETURN(legacy2aidl_uid_t_int32_t(legacy.mUid)));
+ break;
+
+ case RULE_MATCH_USERID:
+ UNION_SET(aidl, userId, VALUE_OR_RETURN(convertReinterpret<uint32_t>(legacy.mUserId)));
+ break;
+
+ default:
+ return unexpected(BAD_VALUE);
+ }
+ return aidl;
+}
+
+
+ConversionResult<AudioMixMatchCriterion>
+aidl2legacy_AudioMixMatchCriterion(const media::AudioMixMatchCriterion& aidl) {
+ AudioMixMatchCriterion legacy;
+ legacy.mValue = VALUE_OR_RETURN(
+ aidl2legacy_AudioMixMatchCriterionValue(aidl.value, &legacy.mRule));
+ if (aidl.invert) {
+ legacy.mRule |= RULE_EXCLUSION_MASK;
+ }
+ return legacy;
+}
+
+ConversionResult<media::AudioMixMatchCriterion>
+legacy2aidl_AudioMixMatchCriterion(const AudioMixMatchCriterion& legacy) {
+ media::AudioMixMatchCriterion aidl;
+ uint32_t rule = legacy.mRule;
+ if (rule & RULE_EXCLUSION_MASK) {
+ aidl.invert = true;
+ rule &= ~RULE_EXCLUSION_MASK;
+ }
+ aidl.value = VALUE_OR_RETURN(legacy2aidl_AudioMixMatchCriterionValue(legacy.mValue, rule));
+ return aidl;
+}
+
+ConversionResult<AudioMix>
+aidl2legacy_AudioMix(const media::AudioMix& aidl) {
+ AudioMix legacy;
+ RETURN_IF_ERROR(convertRange(aidl.criteria.begin(), aidl.criteria.end(),
+ std::back_inserter(legacy.mCriteria),
+ aidl2legacy_AudioMixMatchCriterion));
+ legacy.mMixType = VALUE_OR_RETURN(aidl2legacy_AudioMixType_uint32_t(aidl.mixType));
+ legacy.mFormat = VALUE_OR_RETURN(aidl2legacy_AudioConfig_audio_config_t(aidl.format));
+ legacy.mRouteFlags = VALUE_OR_RETURN(
+ aidl2legacy_AudioMixRouteFlag_uint32_t_mask(aidl.routeFlags));
+ legacy.mDeviceType = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_devices_t(aidl.device.type));
+ legacy.mDeviceAddress = VALUE_OR_RETURN(aidl2legacy_string_view_String8(aidl.device.address));
+ legacy.mCbFlags = VALUE_OR_RETURN(aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(aidl.cbFlags));
+ legacy.mAllowPrivilegedMediaPlaybackCapture = aidl.allowPrivilegedMediaPlaybackCapture;
+ legacy.mVoiceCommunicationCaptureAllowed = aidl.voiceCommunicationCaptureAllowed;
+ return legacy;
+}
+
+ConversionResult<media::AudioMix>
+legacy2aidl_AudioMix(const AudioMix& legacy) {
+ media::AudioMix aidl;
+ aidl.criteria = VALUE_OR_RETURN(
+ convertContainer<std::vector<media::AudioMixMatchCriterion>>(
+ legacy.mCriteria,
+ legacy2aidl_AudioMixMatchCriterion));
+ aidl.mixType = VALUE_OR_RETURN(legacy2aidl_uint32_t_AudioMixType(legacy.mMixType));
+ aidl.format = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(legacy.mFormat));
+ aidl.routeFlags = VALUE_OR_RETURN(
+ legacy2aidl_uint32_t_AudioMixRouteFlag_mask(legacy.mRouteFlags));
+ aidl.device.type = VALUE_OR_RETURN(legacy2aidl_audio_devices_t_int32_t(legacy.mDeviceType));
+ aidl.device.address = VALUE_OR_RETURN(legacy2aidl_String8_string(legacy.mDeviceAddress));
+ aidl.cbFlags = VALUE_OR_RETURN(legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(legacy.mCbFlags));
+ aidl.allowPrivilegedMediaPlaybackCapture = legacy.mAllowPrivilegedMediaPlaybackCapture;
+ aidl.voiceCommunicationCaptureAllowed = legacy.mVoiceCommunicationCaptureAllowed;
+ return aidl;
+}
+
+ConversionResult<audio_policy_dev_state_t>
+aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(media::AudioPolicyDeviceState aidl) {
+ switch (aidl) {
+ case media::AudioPolicyDeviceState::UNAVAILABLE:
+ return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ case media::AudioPolicyDeviceState::AVAILABLE:
+ return AUDIO_POLICY_DEVICE_STATE_AVAILABLE;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyDeviceState>
+legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(audio_policy_dev_state_t legacy) {
+ switch (legacy) {
+ case AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE:
+ return media::AudioPolicyDeviceState::UNAVAILABLE;
+ case AUDIO_POLICY_DEVICE_STATE_AVAILABLE:
+ return media::AudioPolicyDeviceState::AVAILABLE;
+ case AUDIO_POLICY_DEVICE_STATE_CNT:
+ break;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_policy_force_use_t>
+aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(media::AudioPolicyForceUse aidl) {
+ switch (aidl) {
+ case media::AudioPolicyForceUse::COMMUNICATION:
+ return AUDIO_POLICY_FORCE_FOR_COMMUNICATION;
+ case media::AudioPolicyForceUse::MEDIA:
+ return AUDIO_POLICY_FORCE_FOR_MEDIA;
+ case media::AudioPolicyForceUse::RECORD:
+ return AUDIO_POLICY_FORCE_FOR_RECORD;
+ case media::AudioPolicyForceUse::DOCK:
+ return AUDIO_POLICY_FORCE_FOR_DOCK;
+ case media::AudioPolicyForceUse::SYSTEM:
+ return AUDIO_POLICY_FORCE_FOR_SYSTEM;
+ case media::AudioPolicyForceUse::HDMI_SYSTEM_AUDIO:
+ return AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO;
+ case media::AudioPolicyForceUse::ENCODED_SURROUND:
+ return AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND;
+ case media::AudioPolicyForceUse::VIBRATE_RINGING:
+ return AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyForceUse>
+legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(audio_policy_force_use_t legacy) {
+ switch (legacy) {
+ case AUDIO_POLICY_FORCE_FOR_COMMUNICATION:
+ return media::AudioPolicyForceUse::COMMUNICATION;
+ case AUDIO_POLICY_FORCE_FOR_MEDIA:
+ return media::AudioPolicyForceUse::MEDIA;
+ case AUDIO_POLICY_FORCE_FOR_RECORD:
+ return media::AudioPolicyForceUse::RECORD;
+ case AUDIO_POLICY_FORCE_FOR_DOCK:
+ return media::AudioPolicyForceUse::DOCK;
+ case AUDIO_POLICY_FORCE_FOR_SYSTEM:
+ return media::AudioPolicyForceUse::SYSTEM;
+ case AUDIO_POLICY_FORCE_FOR_HDMI_SYSTEM_AUDIO:
+ return media::AudioPolicyForceUse::HDMI_SYSTEM_AUDIO;
+ case AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND:
+ return media::AudioPolicyForceUse::ENCODED_SURROUND;
+ case AUDIO_POLICY_FORCE_FOR_VIBRATE_RINGING:
+ return media::AudioPolicyForceUse::VIBRATE_RINGING;
+ case AUDIO_POLICY_FORCE_USE_CNT:
+ break;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_policy_forced_cfg_t>
+aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(media::AudioPolicyForcedConfig aidl) {
+ switch (aidl) {
+ case media::AudioPolicyForcedConfig::NONE:
+ return AUDIO_POLICY_FORCE_NONE;
+ case media::AudioPolicyForcedConfig::SPEAKER:
+ return AUDIO_POLICY_FORCE_SPEAKER;
+ case media::AudioPolicyForcedConfig::HEADPHONES:
+ return AUDIO_POLICY_FORCE_HEADPHONES;
+ case media::AudioPolicyForcedConfig::BT_SCO:
+ return AUDIO_POLICY_FORCE_BT_SCO;
+ case media::AudioPolicyForcedConfig::BT_A2DP:
+ return AUDIO_POLICY_FORCE_BT_A2DP;
+ case media::AudioPolicyForcedConfig::WIRED_ACCESSORY:
+ return AUDIO_POLICY_FORCE_WIRED_ACCESSORY;
+ case media::AudioPolicyForcedConfig::BT_CAR_DOCK:
+ return AUDIO_POLICY_FORCE_BT_CAR_DOCK;
+ case media::AudioPolicyForcedConfig::BT_DESK_DOCK:
+ return AUDIO_POLICY_FORCE_BT_DESK_DOCK;
+ case media::AudioPolicyForcedConfig::ANALOG_DOCK:
+ return AUDIO_POLICY_FORCE_ANALOG_DOCK;
+ case media::AudioPolicyForcedConfig::DIGITAL_DOCK:
+ return AUDIO_POLICY_FORCE_DIGITAL_DOCK;
+ case media::AudioPolicyForcedConfig::NO_BT_A2DP:
+ return AUDIO_POLICY_FORCE_NO_BT_A2DP;
+ case media::AudioPolicyForcedConfig::SYSTEM_ENFORCED:
+ return AUDIO_POLICY_FORCE_SYSTEM_ENFORCED;
+ case media::AudioPolicyForcedConfig::HDMI_SYSTEM_AUDIO_ENFORCED:
+ return AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED;
+ case media::AudioPolicyForcedConfig::ENCODED_SURROUND_NEVER:
+ return AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER;
+ case media::AudioPolicyForcedConfig::ENCODED_SURROUND_ALWAYS:
+ return AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS;
+ case media::AudioPolicyForcedConfig::ENCODED_SURROUND_MANUAL:
+ return AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioPolicyForcedConfig>
+legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(audio_policy_forced_cfg_t legacy) {
+ switch (legacy) {
+ case AUDIO_POLICY_FORCE_NONE:
+ return media::AudioPolicyForcedConfig::NONE;
+ case AUDIO_POLICY_FORCE_SPEAKER:
+ return media::AudioPolicyForcedConfig::SPEAKER;
+ case AUDIO_POLICY_FORCE_HEADPHONES:
+ return media::AudioPolicyForcedConfig::HEADPHONES;
+ case AUDIO_POLICY_FORCE_BT_SCO:
+ return media::AudioPolicyForcedConfig::BT_SCO;
+ case AUDIO_POLICY_FORCE_BT_A2DP:
+ return media::AudioPolicyForcedConfig::BT_A2DP;
+ case AUDIO_POLICY_FORCE_WIRED_ACCESSORY:
+ return media::AudioPolicyForcedConfig::WIRED_ACCESSORY;
+ case AUDIO_POLICY_FORCE_BT_CAR_DOCK:
+ return media::AudioPolicyForcedConfig::BT_CAR_DOCK;
+ case AUDIO_POLICY_FORCE_BT_DESK_DOCK:
+ return media::AudioPolicyForcedConfig::BT_DESK_DOCK;
+ case AUDIO_POLICY_FORCE_ANALOG_DOCK:
+ return media::AudioPolicyForcedConfig::ANALOG_DOCK;
+ case AUDIO_POLICY_FORCE_DIGITAL_DOCK:
+ return media::AudioPolicyForcedConfig::DIGITAL_DOCK;
+ case AUDIO_POLICY_FORCE_NO_BT_A2DP:
+ return media::AudioPolicyForcedConfig::NO_BT_A2DP;
+ case AUDIO_POLICY_FORCE_SYSTEM_ENFORCED:
+ return media::AudioPolicyForcedConfig::SYSTEM_ENFORCED;
+ case AUDIO_POLICY_FORCE_HDMI_SYSTEM_AUDIO_ENFORCED:
+ return media::AudioPolicyForcedConfig::HDMI_SYSTEM_AUDIO_ENFORCED;
+ case AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER:
+ return media::AudioPolicyForcedConfig::ENCODED_SURROUND_NEVER;
+ case AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS:
+ return media::AudioPolicyForcedConfig::ENCODED_SURROUND_ALWAYS;
+ case AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL:
+ return media::AudioPolicyForcedConfig::ENCODED_SURROUND_MANUAL;
+ case AUDIO_POLICY_FORCE_CFG_CNT:
+ break;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<device_role_t>
+aidl2legacy_DeviceRole_device_role_t(media::DeviceRole aidl) {
+ switch (aidl) {
+ case media::DeviceRole::NONE:
+ return DEVICE_ROLE_NONE;
+ case media::DeviceRole::PREFERRED:
+ return DEVICE_ROLE_PREFERRED;
+ case media::DeviceRole::DISABLED:
+ return DEVICE_ROLE_DISABLED;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::DeviceRole>
+legacy2aidl_device_role_t_DeviceRole(device_role_t legacy) {
+ switch (legacy) {
+ case DEVICE_ROLE_NONE:
+ return media::DeviceRole::NONE;
+ case DEVICE_ROLE_PREFERRED:
+ return media::DeviceRole::PREFERRED;
+ case DEVICE_ROLE_DISABLED:
+ return media::DeviceRole::DISABLED;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<audio_offload_mode_t>
+aidl2legacy_AudioOffloadMode_audio_offload_mode_t(media::AudioOffloadMode aidl) {
+ switch (aidl) {
+ case media::AudioOffloadMode::NOT_SUPPORTED:
+ return AUDIO_OFFLOAD_NOT_SUPPORTED;
+ case media::AudioOffloadMode::SUPPORTED:
+ return AUDIO_OFFLOAD_SUPPORTED;
+ case media::AudioOffloadMode::GAPLESS_SUPPORTED:
+ return AUDIO_OFFLOAD_GAPLESS_SUPPORTED;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+ConversionResult<media::AudioOffloadMode>
+legacy2aidl_audio_offload_mode_t_AudioOffloadMode(audio_offload_mode_t legacy) {
+ switch (legacy) {
+ case AUDIO_OFFLOAD_NOT_SUPPORTED:
+ return media::AudioOffloadMode::NOT_SUPPORTED;
+ case AUDIO_OFFLOAD_SUPPORTED:
+ return media::AudioOffloadMode::SUPPORTED;
+ case AUDIO_OFFLOAD_GAPLESS_SUPPORTED:
+ return media::AudioOffloadMode::GAPLESS_SUPPORTED;
+ }
+ return unexpected(BAD_VALUE);
+}
+
+} // namespace android
diff --git a/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl b/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl
new file mode 100644
index 0000000..04a02c7
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioAttributesEx.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesInternal;
+import android.media.AudioStreamType;
+
+/**
+ * This is the equivalent of the android::AudioAttributes C++ type.
+ * {@hide}
+ */
+parcelable AudioAttributesEx {
+ AudioAttributesInternal attributes;
+ AudioStreamType streamType;
+ /** Interpreted as volume_group_t. */
+ int groupId;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMix.aidl b/media/libaudioclient/aidl/android/media/AudioMix.aidl
new file mode 100644
index 0000000..7473372
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMix.aidl
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioConfig;
+import android.media.AudioDevice;
+import android.media.AudioMixCallbackFlag;
+import android.media.AudioMixMatchCriterion;
+import android.media.AudioMixRouteFlag;
+import android.media.AudioMixType;
+
+/**
+ * {@hide}
+ */
+parcelable AudioMix {
+ AudioMixMatchCriterion[] criteria;
+ AudioMixType mixType;
+ AudioConfig format;
+ /** Bitmask, indexed by AudioMixRouteFlag. */
+ int routeFlags;
+ AudioDevice device;
+ /** Flags indicating which callbacks to use. Bitmask, indexed by AudioMixCallbackFlag. */
+ int cbFlags;
+ /** Ignore the AUDIO_FLAG_NO_MEDIA_PROJECTION */
+ boolean allowPrivilegedMediaPlaybackCapture;
+ /** Indicates if the caller can capture voice communication output */
+ boolean voiceCommunicationCaptureAllowed;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl b/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl
new file mode 100644
index 0000000..6cb3d38
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixCallbackFlag.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixCallbackFlag {
+ NOTIFY_ACTIVITY = 0,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl
new file mode 100644
index 0000000..2c63dc5
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterion.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioMixMatchCriterionValue;
+
+/**
+ * {@hide}
+ */
+parcelable AudioMixMatchCriterion {
+ /** When true, rule becomes "exclude" instead of "include". */
+ boolean invert;
+ AudioMixMatchCriterionValue value;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl
new file mode 100644
index 0000000..e26a9e1
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixMatchCriterionValue.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioSourceType;
+import android.media.AudioUsage;
+
+/**
+ * {@hide}
+ */
+union AudioMixMatchCriterionValue {
+ AudioUsage usage = AudioUsage.UNKNOWN;
+ AudioSourceType source;
+ /** Interpreted as uid_t. */
+ int uid;
+ int userId;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl b/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl
new file mode 100644
index 0000000..f0cce2d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixRouteFlag.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixRouteFlag {
+ RENDER = 0,
+ LOOP_BACK = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioMixType.aidl b/media/libaudioclient/aidl/android/media/AudioMixType.aidl
new file mode 100644
index 0000000..b6806dc
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioMixType.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioMixType {
+ PLAYERS = 0,
+ RECORDERS = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl b/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl
new file mode 100644
index 0000000..45a44f2
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioOffloadMode.aidl
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioOffloadMode {
+ NOT_SUPPORTED = 0,
+ SUPPORTED = 1,
+ GAPLESS_SUPPORTED = 2
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl
new file mode 100644
index 0000000..a1072d2
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyDeviceState.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyDeviceState {
+ UNAVAILABLE = 0,
+ AVAILABLE = 1,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl
new file mode 100644
index 0000000..9bb0605
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyForceUse.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyForceUse {
+ COMMUNICATION = 0,
+ MEDIA = 1,
+ RECORD = 2,
+ DOCK = 3,
+ SYSTEM = 4,
+ HDMI_SYSTEM_AUDIO = 5,
+ ENCODED_SURROUND = 6,
+ VIBRATE_RINGING = 7,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl b/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl
new file mode 100644
index 0000000..2255d4c
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioPolicyForcedConfig.aidl
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum AudioPolicyForcedConfig {
+ NONE = 0,
+ SPEAKER = 1,
+ HEADPHONES = 2,
+ BT_SCO = 3,
+ BT_A2DP = 4,
+ WIRED_ACCESSORY = 5,
+ BT_CAR_DOCK = 6,
+ BT_DESK_DOCK = 7,
+ ANALOG_DOCK = 8,
+ DIGITAL_DOCK = 9,
+ NO_BT_A2DP = 10, /* A2DP sink is not preferred to speaker or wired HS */
+ SYSTEM_ENFORCED = 11,
+ HDMI_SYSTEM_AUDIO_ENFORCED = 12,
+ ENCODED_SURROUND_NEVER = 13,
+ ENCODED_SURROUND_ALWAYS = 14,
+ ENCODED_SURROUND_MANUAL = 15,
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl b/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl
new file mode 100644
index 0000000..56c4a44
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioProductStrategy.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesEx;
+
+/**
+ * {@hide}
+ */
+parcelable AudioProductStrategy {
+ /** Interpreted as product_strategy_t. */
+ int id;
+ @utf8InCpp String name;
+ AudioAttributesEx[] audioAttributes;
+}
diff --git a/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl b/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl
new file mode 100644
index 0000000..3a29a08
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/AudioVolumeGroup.aidl
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioAttributesInternal;
+import android.media.AudioStreamType;
+
+/**
+ * {@hide}
+ */
+parcelable AudioVolumeGroup {
+ /** Interpreted as volume_group_t. */
+ int groupId;
+ @utf8InCpp String name;
+ AudioAttributesInternal[] audioAttributes;
+ AudioStreamType[] streams;
+}
diff --git a/media/libaudioclient/aidl/android/media/DeviceRole.aidl b/media/libaudioclient/aidl/android/media/DeviceRole.aidl
new file mode 100644
index 0000000..b741843
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/DeviceRole.aidl
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+@Backing(type="int")
+enum DeviceRole {
+ /** Default routing rules and priority apply. */
+ NONE = 0,
+ /* Devices are specified as preferred devices. */
+ PREFERRED = 1,
+ /* Devices cannot be used. */
+ DISABLED = 2,
+}
diff --git a/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl b/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl
new file mode 100644
index 0000000..9696124
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/GetInputForAttrResponse.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+parcelable GetInputForAttrResponse {
+ /** Interpreted as audio_io_handle_t. */
+ int input;
+ /** Interpreted as audio_port_handle_t. */
+ int selectedDeviceId;
+ /** Interpreted as audio_port_handle_t. */
+ int portId;
+}
diff --git a/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl b/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl
new file mode 100644
index 0000000..164fb9d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/GetOutputForAttrResponse.aidl
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.AudioStreamType;
+
+/**
+ * {@hide}
+ */
+parcelable GetOutputForAttrResponse {
+ /** Interpreted as audio_io_handle_t. */
+ int output;
+ AudioStreamType stream;
+ /** Interpreted as audio_port_handle_t. */
+ int selectedDeviceId;
+ /** Interpreted as audio_port_handle_t. */
+ int portId;
+ /** Interpreted as audio_io_handle_t[]. */
+ int[] secondaryOutputs;
+}
diff --git a/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl b/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl
new file mode 100644
index 0000000..f3a086d
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/IAudioPolicyService.aidl
@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+import android.media.audio.common.AudioFormat;
+
+import android.media.AudioAttributesEx;
+import android.media.AudioAttributesInternal;
+import android.media.AudioConfig;
+import android.media.AudioConfigBase;
+import android.media.AudioDevice;
+import android.media.AudioMix;
+import android.media.AudioMode;
+import android.media.AudioOffloadInfo;
+import android.media.AudioOffloadMode;
+import android.media.AudioPatch;
+import android.media.AudioPolicyDeviceState;
+import android.media.AudioPolicyForcedConfig;
+import android.media.AudioPolicyForceUse;
+import android.media.AudioPort;
+import android.media.AudioPortConfig;
+import android.media.AudioPortRole;
+import android.media.AudioPortType;
+import android.media.AudioProductStrategy;
+import android.media.AudioSourceType;
+import android.media.AudioStreamType;
+import android.media.AudioUsage;
+import android.media.AudioUuid;
+import android.media.AudioVolumeGroup;
+import android.media.DeviceRole;
+import android.media.EffectDescriptor;
+import android.media.GetInputForAttrResponse;
+import android.media.GetOutputForAttrResponse;
+import android.media.IAudioPolicyServiceClient;
+import android.media.ICaptureStateListener;
+import android.media.Int;
+import android.media.SoundTriggerSession;
+
+/**
+ * IAudioPolicyService interface (see AudioPolicyInterface for method descriptions).
+ *
+ * {@hide}
+ */
+interface IAudioPolicyService {
+ oneway void onNewAudioModulesAvailable();
+
+ void setDeviceConnectionState(in AudioDevice device,
+ in AudioPolicyDeviceState state,
+ @utf8InCpp String deviceName,
+ in AudioFormat encodedFormat);
+
+ AudioPolicyDeviceState getDeviceConnectionState(in AudioDevice device);
+
+ void handleDeviceConfigChange(in AudioDevice device,
+ @utf8InCpp String deviceName,
+ in AudioFormat encodedFormat);
+
+ void setPhoneState(AudioMode state, int /* uid_t */ uid);
+
+ void setForceUse(AudioPolicyForceUse usage,
+ AudioPolicyForcedConfig config);
+
+ AudioPolicyForcedConfig getForceUse(AudioPolicyForceUse usage);
+
+ int /* audio_io_handle_t */ getOutput(AudioStreamType stream);
+
+ GetOutputForAttrResponse getOutputForAttr(in AudioAttributesInternal attr,
+ int /* audio_session_t */ session,
+ int /* pid_t */ pid,
+ int /* uid_t */ uid,
+ in AudioConfig config,
+ int /* Bitmask, indexed by AudioOutputFlags */ flags);
+
+ void startOutput(int /* audio_port_handle_t */ portId);
+
+ void stopOutput(int /* audio_port_handle_t */ portId);
+
+ void releaseOutput(int /* audio_port_handle_t */ portId);
+
+ GetInputForAttrResponse getInputForAttr(in AudioAttributesInternal attr,
+ int /* audio_io_handle_t */ input,
+ int /* audio_unique_id_t */ riid,
+ int /* audio_session_t */ session,
+ int /* pid_t */ pid,
+ int /* uid_t */ uid,
+ @utf8InCpp String opPackageName,
+ in AudioConfigBase config,
+ int /* Bitmask, indexed by AudioInputFlags */ flags);
+
+ void startInput(int /* audio_port_handle_t */ portId);
+
+ void stopInput(int /* audio_port_handle_t */ portId);
+
+ void releaseInput(int /* audio_port_handle_t */ portId);
+
+ void initStreamVolume(AudioStreamType stream,
+ int indexMin,
+ int indexMax);
+
+ void setStreamVolumeIndex(AudioStreamType stream,
+ int /* audio_devices_t */ device,
+ int index);
+
+ int getStreamVolumeIndex(AudioStreamType stream,
+ int /* audio_devices_t */ device);
+
+ void setVolumeIndexForAttributes(in AudioAttributesInternal attr,
+ int /* audio_devices_t */ device,
+ int index);
+
+ int getVolumeIndexForAttributes(in AudioAttributesInternal attr,
+ int /* audio_devices_t */ device);
+
+ int getMaxVolumeIndexForAttributes(in AudioAttributesInternal attr);
+
+ int getMinVolumeIndexForAttributes(in AudioAttributesInternal attr);
+
+ int /* product_strategy_t */ getStrategyForStream(AudioStreamType stream);
+
+ int /* bitmask of audio_devices_t */ getDevicesForStream(AudioStreamType stream);
+
+ AudioDevice[] getDevicesForAttributes(in AudioAttributesEx attr);
+
+ int /* audio_io_handle_t */ getOutputForEffect(in EffectDescriptor desc);
+
+ void registerEffect(in EffectDescriptor desc,
+ int /* audio_io_handle_t */ io,
+ int /* product_strategy_t */ strategy,
+ int /* audio_session_t */ session,
+ int id);
+
+ void unregisterEffect(int id);
+
+ void setEffectEnabled(int id, boolean enabled);
+
+ void moveEffectsToIo(in int[] ids, int /* audio_io_handle_t */ io);
+
+ boolean isStreamActive(AudioStreamType stream, int inPastMs);
+
+ boolean isStreamActiveRemotely(AudioStreamType stream, int inPastMs);
+
+ boolean isSourceActive(AudioSourceType source);
+
+ /**
+ * On input, count represents the maximum length of the returned array.
+ * On output, count is the total number of elements, which may be larger than the array size.
+ * Passing '0' on input and inspecting the value on output is a common way of determining the
+ * number of elements without actually retrieving them.
+ */
+ EffectDescriptor[] queryDefaultPreProcessing(int /* audio_session_t */ audioSession,
+ inout Int count);
+
+ int /* audio_unique_id_t */ addSourceDefaultEffect(in AudioUuid type,
+ @utf8InCpp String opPackageName,
+ in AudioUuid uuid,
+ int priority,
+ AudioSourceType source);
+
+ int /* audio_unique_id_t */ addStreamDefaultEffect(in AudioUuid type,
+ @utf8InCpp String opPackageName,
+ in AudioUuid uuid,
+ int priority,
+ AudioUsage usage);
+
+ void removeSourceDefaultEffect(int /* audio_unique_id_t */ id);
+
+ void removeStreamDefaultEffect(int /* audio_unique_id_t */ id);
+
+ void setSupportedSystemUsages(in AudioUsage[] systemUsages);
+
+ void setAllowedCapturePolicy(int /* uid_t */ uid,
+ int /* Bitmask of AudioFlags */ capturePolicy);
+
+ /**
+ * Check if offload is possible for given format, stream type, sample rate,
+ * bit rate, duration, video and streaming or offload property is enabled.
+ */
+ AudioOffloadMode getOffloadSupport(in AudioOffloadInfo info);
+
+ /**
+ * Check if direct playback is possible for given format, sample rate, channel mask and flags.
+ */
+ boolean isDirectOutputSupported(in AudioConfigBase config,
+ in AudioAttributesInternal attributes);
+
+ /**
+ * List available audio ports and their attributes. Returns the generation.
+ *
+ * On input, count represents the maximum length of the returned array.
+ * On output, count is the total number of elements, which may be larger than the array size.
+ * Passing '0' on input and inspecting the value on output is a common way of determining the
+ * number of elements without actually retrieving them.
+ */
+ int listAudioPorts(AudioPortRole role,
+ AudioPortType type,
+ inout Int count,
+ out AudioPort[] ports);
+
+ /** Get attributes for a given audio port. */
+ AudioPort getAudioPort(in AudioPort port);
+
+ /**
+ * Create an audio patch between several source and sink ports.
+ * The handle argument is used when updating an existing patch.
+ */
+ int /* audio_patch_handle_t */ createAudioPatch(in AudioPatch patch, int handle);
+
+ /** Release an audio patch. */
+ void releaseAudioPatch(int /* audio_patch_handle_t */ handle);
+
+ /**
+ * List existing audio patches. Returns the generation.
+ *
+ * On input, count represents the maximum length of the returned array.
+ * On output, count is the total number of elements, which may be larger than the array size.
+ * Passing '0' on input and inspecting the value on output is a common way of determining the
+ * number of elements without actually retrieving them.
+ */
+ int listAudioPatches(inout Int count, out AudioPatch[] patches);
+
+ /** Set audio port configuration. */
+ void setAudioPortConfig(in AudioPortConfig config);
+
+ void registerClient(IAudioPolicyServiceClient client);
+
+ void setAudioPortCallbacksEnabled(boolean enabled);
+
+ void setAudioVolumeGroupCallbacksEnabled(boolean enabled);
+
+ SoundTriggerSession acquireSoundTriggerSession();
+
+ void releaseSoundTriggerSession(int /* audio_session_t */ session);
+
+ AudioMode getPhoneState();
+
+ void registerPolicyMixes(in AudioMix[] mixes, boolean registration);
+
+ void setUidDeviceAffinities(int /* uid_t */ uid, in AudioDevice[] devices);
+
+ void removeUidDeviceAffinities(int /* uid_t */ uid);
+
+ void setUserIdDeviceAffinities(int userId, in AudioDevice[] devices);
+
+ void removeUserIdDeviceAffinities(int userId);
+
+ int /* audio_port_handle_t */ startAudioSource(in AudioPortConfig source,
+ in AudioAttributesInternal attributes);
+
+ void stopAudioSource(int /* audio_port_handle_t */ portId);
+
+ void setMasterMono(boolean mono);
+
+ boolean getMasterMono();
+
+ float getStreamVolumeDB(AudioStreamType stream, int index, int /* audio_devices_t */ device);
+
+ /**
+ * Returns whether surround formats are enabled.
+ *
+ * On input, count represents the maximum length of the returned array.
+ * On output, count is the total number of elements, which may be larger than the array size.
+ * Passing '0' on input and inspecting the value on output is a common way of determining the
+ * number of elements without actually retrieving them.
+ */
+ boolean getSurroundFormats(boolean reported,
+ inout Int count,
+ out AudioFormat[] formats);
+
+ AudioFormat[] getHwOffloadEncodingFormatsSupportedForA2DP();
+
+ void setSurroundFormatEnabled(AudioFormat audioFormat, boolean enabled);
+
+ void setAssistantUid(int /* uid_t */ uid);
+
+ void setA11yServicesUids(in int[] /* uid_t[] */ uids);
+
+ void setCurrentImeUid(int /* uid_t */ uid);
+
+ boolean isHapticPlaybackSupported();
+
+ AudioProductStrategy[] listAudioProductStrategies();
+ int /* product_strategy_t */ getProductStrategyFromAudioAttributes(in AudioAttributesEx aa);
+
+ AudioVolumeGroup[] listAudioVolumeGroups();
+ int /* volume_group_t */ getVolumeGroupFromAudioAttributes(in AudioAttributesEx aa);
+
+ void setRttEnabled(boolean enabled);
+
+ boolean isCallScreenModeSupported();
+
+ void setDevicesRoleForStrategy(int /* product_strategy_t */ strategy,
+ DeviceRole role,
+ in AudioDevice[] devices);
+
+ void removeDevicesRoleForStrategy(int /* product_strategy_t */ strategy,
+ DeviceRole role);
+
+ AudioDevice[] getDevicesForRoleAndStrategy(int /* product_strategy_t */ strategy,
+ DeviceRole role);
+
+ void setDevicesRoleForCapturePreset(AudioSourceType audioSource,
+ DeviceRole role,
+ in AudioDevice[] devices);
+
+ void addDevicesRoleForCapturePreset(AudioSourceType audioSource,
+ DeviceRole role,
+ in AudioDevice[] devices);
+
+ void removeDevicesRoleForCapturePreset(AudioSourceType audioSource,
+ DeviceRole role,
+ in AudioDevice[] devices);
+
+ void clearDevicesRoleForCapturePreset(AudioSourceType audioSource,
+ DeviceRole role);
+
+ AudioDevice[] getDevicesForRoleAndCapturePreset(AudioSourceType audioSource,
+ DeviceRole role);
+
+ boolean registerSoundTriggerCaptureStateListener(ICaptureStateListener listener);
+}
diff --git a/media/libaudioclient/aidl/android/media/Int.aidl b/media/libaudioclient/aidl/android/media/Int.aidl
new file mode 100644
index 0000000..24f4d62
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/Int.aidl
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * This is a simple wrapper around an 'int', putting it in a parcelable, so it can be used as an
+ * inout parameter, be made @nullable, etc.
+ *
+ * {@hide}
+ */
+parcelable Int {
+ int value;
+}
diff --git a/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl b/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl
new file mode 100644
index 0000000..a829e59
--- /dev/null
+++ b/media/libaudioclient/aidl/android/media/SoundTriggerSession.aidl
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package android.media;
+
+/**
+ * {@hide}
+ */
+parcelable SoundTriggerSession {
+ /** Interpreted as audio_session_t. */
+ int session;
+ /** Interpreted as audio_io_handle_t. */
+ int ioHandle;
+ /** Interpreted as audio_devices_t. */
+ int device;
+}
diff --git a/media/libaudioclient/include/media/AudioAttributes.h b/media/libaudioclient/include/media/AudioAttributes.h
index 001c629..24bd179 100644
--- a/media/libaudioclient/include/media/AudioAttributes.h
+++ b/media/libaudioclient/include/media/AudioAttributes.h
@@ -17,7 +17,9 @@
#pragma once
+#include <android/media/AudioAttributesEx.h>
#include <media/AudioCommonTypes.h>
+#include <media/AidlConversionUtil.h>
#include <system/audio.h>
#include <system/audio_policy.h>
#include <binder/Parcelable.h>
@@ -57,4 +59,10 @@
volume_group_t mGroupId = VOLUME_GROUP_NONE;
};
+// AIDL conversion routines.
+ConversionResult<media::AudioAttributesEx>
+legacy2aidl_AudioAttributes_AudioAttributesEx(const AudioAttributes& legacy);
+ConversionResult<AudioAttributes>
+aidl2legacy_AudioAttributesEx_AudioAttributes(const media::AudioAttributesEx& aidl);
+
} // namespace android
diff --git a/media/libaudioclient/include/media/AudioEffect.h b/media/libaudioclient/include/media/AudioEffect.h
index 8371711..0d18fb1 100644
--- a/media/libaudioclient/include/media/AudioEffect.h
+++ b/media/libaudioclient/include/media/AudioEffect.h
@@ -21,7 +21,6 @@
#include <sys/types.h>
#include <media/IAudioFlinger.h>
-#include <media/IAudioPolicyService.h>
#include <media/AudioSystem.h>
#include <system/audio_effect.h>
diff --git a/media/libaudioclient/include/media/AudioProductStrategy.h b/media/libaudioclient/include/media/AudioProductStrategy.h
index 7441095..b55b506 100644
--- a/media/libaudioclient/include/media/AudioProductStrategy.h
+++ b/media/libaudioclient/include/media/AudioProductStrategy.h
@@ -17,6 +17,8 @@
#pragma once
+#include <android/media/AudioProductStrategy.h>
+#include <media/AidlConversionUtil.h>
#include <media/AudioCommonTypes.h>
#include <media/AudioAttributes.h>
#include <system/audio.h>
@@ -62,5 +64,11 @@
using AudioProductStrategyVector = std::vector<AudioProductStrategy>;
+// AIDL conversion routines.
+ConversionResult<media::AudioProductStrategy>
+legacy2aidl_AudioProductStrategy(const AudioProductStrategy& legacy);
+ConversionResult<AudioProductStrategy>
+aidl2legacy_AudioProductStrategy(const media::AudioProductStrategy& aidl);
+
} // namespace android
diff --git a/media/libaudioclient/include/media/AudioSystem.h b/media/libaudioclient/include/media/AudioSystem.h
index 71b1e33..db4c28f 100644
--- a/media/libaudioclient/include/media/AudioSystem.h
+++ b/media/libaudioclient/include/media/AudioSystem.h
@@ -68,9 +68,12 @@
typedef void (*routing_callback)();
class IAudioFlinger;
-class IAudioPolicyService;
class String8;
+namespace media {
+class IAudioPolicyService;
+}
+
class AudioSystem
{
public:
@@ -308,7 +311,7 @@
static status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index);
- static uint32_t getStrategyForStream(audio_stream_type_t stream);
+ static product_strategy_t getStrategyForStream(audio_stream_type_t stream);
static audio_devices_t getDevicesForStream(audio_stream_type_t stream);
static status_t getDevicesForAttributes(const AudioAttributes &aa,
AudioDeviceTypeAddrVector *devices);
@@ -316,7 +319,7 @@
static audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
static status_t registerEffect(const effect_descriptor_t *desc,
audio_io_handle_t io,
- uint32_t strategy,
+ product_strategy_t strategy,
audio_session_t session,
int id);
static status_t unregisterEffect(int id);
@@ -327,7 +330,7 @@
// and output configuration cache (gOutputs)
static void clearAudioConfigCache();
- static const sp<IAudioPolicyService> get_audio_policy_service();
+ static const sp<media::IAudioPolicyService> get_audio_policy_service();
// helpers for android.media.AudioManager.getProperty(), see description there for meaning
static uint32_t getPrimaryOutputSamplingRate();
@@ -337,7 +340,7 @@
static status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages);
- static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags);
+ static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy);
// Indicate if hw offload is possible for given format, stream type, sample rate,
// bit rate, duration, video and streaming or offload property is enabled and when possible
@@ -667,7 +670,7 @@
static audio_format_t gPrevInFormat;
static audio_channel_mask_t gPrevInChannelMask;
- static sp<IAudioPolicyService> gAudioPolicyService;
+ static sp<media::IAudioPolicyService> gAudioPolicyService;
};
}; // namespace android
diff --git a/media/libaudioclient/include/media/AudioVolumeGroup.h b/media/libaudioclient/include/media/AudioVolumeGroup.h
index 9a6ea07..946d58a 100644
--- a/media/libaudioclient/include/media/AudioVolumeGroup.h
+++ b/media/libaudioclient/include/media/AudioVolumeGroup.h
@@ -17,6 +17,8 @@
#pragma once
+#include <android/media/AudioVolumeGroup.h>
+#include <media/AidlConversionUtil.h>
#include <media/AudioProductStrategy.h>
#include <system/audio.h>
#include <system/audio_policy.h>
@@ -51,4 +53,10 @@
using AudioVolumeGroupVector = std::vector<AudioVolumeGroup>;
+// AIDL conversion routines.
+ConversionResult<media::AudioVolumeGroup>
+legacy2aidl_AudioVolumeGroup(const AudioVolumeGroup& legacy);
+ConversionResult<AudioVolumeGroup>
+aidl2legacy_AudioVolumeGroup(const media::AudioVolumeGroup& aidl);
+
} // namespace android
diff --git a/media/libaudioclient/include/media/IAudioPolicyService.h b/media/libaudioclient/include/media/IAudioPolicyService.h
deleted file mode 100644
index 3018364..0000000
--- a/media/libaudioclient/include/media/IAudioPolicyService.h
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ANDROID_IAUDIOPOLICYSERVICE_H
-#define ANDROID_IAUDIOPOLICYSERVICE_H
-
-#include <stdint.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <android/media/IAudioPolicyServiceClient.h>
-#include <binder/IInterface.h>
-#include <media/AudioDeviceTypeAddr.h>
-#include <media/AudioSystem.h>
-#include <media/AudioPolicy.h>
-#include <system/audio_policy.h>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <vector>
-
-namespace android {
-namespace media {
-// Must be pre-declared, or else there isn't a good way to generate a header
-// library.
-class ICaptureStateListener;
-}
-
-// ----------------------------------------------------------------------------
-
-class IAudioPolicyService : public IInterface
-{
-public:
- DECLARE_META_INTERFACE(AudioPolicyService);
-
- //
- // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)
- //
- virtual void onNewAudioModulesAvailable() = 0;
- virtual status_t setDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat) = 0;
- virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,
- const char *device_address) = 0;
- virtual status_t handleDeviceConfigChange(audio_devices_t device,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat) = 0;
- virtual status_t setPhoneState(audio_mode_t state, uid_t uid) = 0;
- virtual status_t setForceUse(audio_policy_force_use_t usage,
- audio_policy_forced_cfg_t config) = 0;
- virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0;
- virtual audio_io_handle_t getOutput(audio_stream_type_t stream) = 0;
- virtual status_t getOutputForAttr(audio_attributes_t *attr,
- audio_io_handle_t *output,
- audio_session_t session,
- audio_stream_type_t *stream,
- pid_t pid,
- uid_t uid,
- const audio_config_t *config,
- audio_output_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId,
- std::vector<audio_io_handle_t> *secondaryOutputs) = 0;
- virtual status_t startOutput(audio_port_handle_t portId) = 0;
- virtual status_t stopOutput(audio_port_handle_t portId) = 0;
- virtual void releaseOutput(audio_port_handle_t portId) = 0;
- virtual status_t getInputForAttr(const audio_attributes_t *attr,
- audio_io_handle_t *input,
- audio_unique_id_t riid,
- audio_session_t session,
- pid_t pid,
- uid_t uid,
- const String16& opPackageName,
- const audio_config_base_t *config,
- audio_input_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId) = 0;
- virtual status_t startInput(audio_port_handle_t portId) = 0;
- virtual status_t stopInput(audio_port_handle_t portId) = 0;
- virtual void releaseInput(audio_port_handle_t portId) = 0;
- virtual status_t initStreamVolume(audio_stream_type_t stream,
- int indexMin,
- int indexMax) = 0;
- virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device) = 0;
- virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
- int *index,
- audio_devices_t device) = 0;
-
- virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
- int index,
- audio_devices_t device) = 0;
- virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
- int &index,
- audio_devices_t device) = 0;
- virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
-
- virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index) = 0;
-
- virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
- virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
- virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
- AudioDeviceTypeAddrVector *devices) const = 0;
- virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
- virtual status_t registerEffect(const effect_descriptor_t *desc,
- audio_io_handle_t io,
- uint32_t strategy,
- audio_session_t session,
- int id) = 0;
- virtual status_t unregisterEffect(int id) = 0;
- virtual status_t setEffectEnabled(int id, bool enabled) = 0;
- virtual status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) = 0;
- virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0;
- virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0)
- const = 0;
- virtual bool isSourceActive(audio_source_t source) const = 0;
- virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
- effect_descriptor_t *descriptors,
- uint32_t *count) = 0;
- virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_source_t source,
- audio_unique_id_t* id) = 0;
- virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_usage_t usage,
- audio_unique_id_t* id) = 0;
- virtual status_t removeSourceDefaultEffect(audio_unique_id_t id) = 0;
- virtual status_t removeStreamDefaultEffect(audio_unique_id_t id) = 0;
- virtual status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) = 0;
- virtual status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) = 0;
- // Check if offload is possible for given format, stream type, sample rate,
- // bit rate, duration, video and streaming or offload property is enabled
- virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info) = 0;
-
- // Check if direct playback is possible for given format, sample rate, channel mask and flags.
- virtual bool isDirectOutputSupported(const audio_config_base_t& config,
- const audio_attributes_t& attributes) = 0;
-
- /* List available audio ports and their attributes */
- virtual status_t listAudioPorts(audio_port_role_t role,
- audio_port_type_t type,
- unsigned int *num_ports,
- struct audio_port_v7 *ports,
- unsigned int *generation) = 0;
-
- /* Get attributes for a given audio port */
- virtual status_t getAudioPort(struct audio_port_v7 *port) = 0;
-
- /* Create an audio patch between several source and sink ports */
- virtual status_t createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle) = 0;
-
- /* Release an audio patch */
- virtual status_t releaseAudioPatch(audio_patch_handle_t handle) = 0;
-
- /* List existing audio patches */
- virtual status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches,
- unsigned int *generation) = 0;
- /* Set audio port configuration */
- virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0;
-
- virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client) = 0;
-
- virtual void setAudioPortCallbacksEnabled(bool enabled) = 0;
-
- virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled) = 0;
-
- virtual status_t acquireSoundTriggerSession(audio_session_t *session,
- audio_io_handle_t *ioHandle,
- audio_devices_t *device) = 0;
-
- virtual status_t releaseSoundTriggerSession(audio_session_t session) = 0;
-
- virtual audio_mode_t getPhoneState() = 0;
-
- virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration) = 0;
-
- virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices)
- = 0;
-
- virtual status_t removeUidDeviceAffinities(uid_t uid) = 0;
-
- virtual status_t setUserIdDeviceAffinities(int userId,
- const AudioDeviceTypeAddrVector& devices) = 0;
-
- virtual status_t removeUserIdDeviceAffinities(int userId) = 0;
-
- virtual status_t startAudioSource(const struct audio_port_config *source,
- const audio_attributes_t *attributes,
- audio_port_handle_t *portId) = 0;
- virtual status_t stopAudioSource(audio_port_handle_t portId) = 0;
-
- virtual status_t setMasterMono(bool mono) = 0;
- virtual status_t getMasterMono(bool *mono) = 0;
- virtual float getStreamVolumeDB(
- audio_stream_type_t stream, int index, audio_devices_t device) = 0;
-
- virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
- audio_format_t *surroundFormats,
- bool *surroundFormatsEnabled,
- bool reported) = 0;
- virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
- std::vector<audio_format_t> *formats) = 0;
- virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) = 0;
-
- virtual status_t setAssistantUid(uid_t uid) = 0;
- virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids) = 0;
- virtual status_t setCurrentImeUid(uid_t uid) = 0;
-
- virtual bool isHapticPlaybackSupported() = 0;
- virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0;
- virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
- product_strategy_t &productStrategy) = 0;
-
- virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0;
- virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
- volume_group_t &volumeGroup) = 0;
-
- virtual status_t setRttEnabled(bool enabled) = 0;
-
- virtual bool isCallScreenModeSupported() = 0;
-
- virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices) = 0;
-
- virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role) = 0;
-
- virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices) = 0;
-
- virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices) = 0;
-
- virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices) = 0;
-
- virtual status_t removeDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role,
- const AudioDeviceTypeAddrVector& devices) = 0;
-
- virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role) = 0;
-
- virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices) = 0;
-
- // The return code here is only intended to represent transport errors. The
- // actual server implementation should always return NO_ERROR.
- virtual status_t registerSoundTriggerCaptureStateListener(
- const sp<media::ICaptureStateListener>& listener,
- bool* result) = 0;
-};
-
-
-// ----------------------------------------------------------------------------
-
-class BnAudioPolicyService : public BnInterface<IAudioPolicyService>
-{
-public:
- virtual status_t onTransact( uint32_t code,
- const Parcel& data,
- Parcel* reply,
- uint32_t flags = 0);
-};
-
-// ----------------------------------------------------------------------------
-
-}; // namespace android
-
-#endif // ANDROID_IAUDIOPOLICYSERVICE_H
diff --git a/media/libaudioclient/include/media/PolicyAidlConversion.h b/media/libaudioclient/include/media/PolicyAidlConversion.h
new file mode 100644
index 0000000..873f27a
--- /dev/null
+++ b/media/libaudioclient/include/media/PolicyAidlConversion.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#pragma once
+
+#include <limits>
+#include <type_traits>
+
+#include <system/audio.h>
+
+#include <android/media/AudioMix.h>
+#include <android/media/AudioMixCallbackFlag.h>
+#include <android/media/AudioMixLatencyClass.h>
+#include <android/media/AudioMixRouteFlag.h>
+#include <android/media/AudioMixType.h>
+#include <android/media/AudioMode.h>
+#include <android/media/AudioOffloadMode.h>
+#include <android/media/AudioPolicyForceUse.h>
+#include <android/media/AudioPolicyForcedConfig.h>
+#include <android/media/DeviceRole.h>
+
+#include <media/AidlConversionUtil.h>
+#include <media/AudioCommonTypes.h>
+#include <media/AudioPolicy.h>
+#include <android/media/AudioPolicyDeviceState.h>
+
+namespace android {
+
+ConversionResult<volume_group_t>
+aidl2legacy_int32_t_volume_group_t(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_volume_group_t_int32_t(volume_group_t legacy);
+
+ConversionResult<product_strategy_t>
+aidl2legacy_int32_t_product_strategy_t(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_product_strategy_t_int32_t(product_strategy_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixType_uint32_t(media::AudioMixType aidl);
+ConversionResult<media::AudioMixType>
+legacy2aidl_uint32_t_AudioMixType(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t(media::AudioMixCallbackFlag aidl);
+ConversionResult<media::AudioMixCallbackFlag>
+legacy2aidl_uint32_t_AudioMixCallbackFlag(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixCallbackFlag_uint32_t_mask(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixCallbackFlag_mask(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t(media::AudioMixRouteFlag aidl);
+ConversionResult<media::AudioMixRouteFlag>
+legacy2aidl_uint32_t_AudioMixRouteFlag(uint32_t legacy);
+
+ConversionResult<uint32_t>
+aidl2legacy_AudioMixRouteFlag_uint32_t_mask(int32_t aidl);
+ConversionResult<int32_t>
+legacy2aidl_uint32_t_AudioMixRouteFlag_mask(uint32_t legacy);
+
+ConversionResult<AudioMixMatchCriterion>
+aidl2legacy_AudioMixMatchCriterion(const media::AudioMixMatchCriterion& aidl);
+ConversionResult<media::AudioMixMatchCriterion>
+legacy2aidl_AudioMixMatchCriterion(const AudioMixMatchCriterion& legacy);
+
+ConversionResult<AudioMix>
+aidl2legacy_AudioMix(const media::AudioMix& aidl);
+ConversionResult<media::AudioMix>
+legacy2aidl_AudioMix(const AudioMix& legacy);
+
+ConversionResult<audio_policy_dev_state_t>
+aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(media::AudioPolicyDeviceState aidl);
+ConversionResult<media::AudioPolicyDeviceState>
+legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(audio_policy_dev_state_t legacy);
+
+ConversionResult<audio_policy_force_use_t>
+aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(media::AudioPolicyForceUse aidl);
+ConversionResult<media::AudioPolicyForceUse>
+legacy2aidl_audio_policy_force_use_t_AudioPolicyForceUse(audio_policy_force_use_t legacy);
+
+ConversionResult<audio_policy_forced_cfg_t>
+aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(media::AudioPolicyForcedConfig aidl);
+ConversionResult<media::AudioPolicyForcedConfig>
+legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(audio_policy_forced_cfg_t legacy);
+
+ConversionResult<device_role_t>
+aidl2legacy_DeviceRole_device_role_t(media::DeviceRole aidl);
+ConversionResult<media::DeviceRole>
+legacy2aidl_device_role_t_DeviceRole(device_role_t legacy);
+
+ConversionResult<audio_offload_mode_t>
+aidl2legacy_AudioOffloadMode_audio_offload_mode_t(media::AudioOffloadMode aidl);
+ConversionResult<media::AudioOffloadMode>
+legacy2aidl_audio_offload_mode_t_AudioOffloadMode(audio_offload_mode_t legacy);
+
+} // namespace android
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index b8257d3..dc2c171 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -31,7 +31,7 @@
#include <sys/resource.h>
#include <thread>
-
+#include <android/media/IAudioPolicyService.h>
#include <android/os/IExternalVibratorService.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
@@ -42,7 +42,6 @@
#include <media/audiohal/DevicesFactoryHalInterface.h>
#include <media/audiohal/EffectsFactoryHalInterface.h>
#include <media/AudioParameter.h>
-#include <media/IAudioPolicyService.h>
#include <media/MediaMetricsItem.h>
#include <media/TypeConverter.h>
#include <mediautils/TimeCheck.h>
diff --git a/services/audioflinger/DeviceEffectManager.h b/services/audioflinger/DeviceEffectManager.h
index d187df2..a05f5fe 100644
--- a/services/audioflinger/DeviceEffectManager.h
+++ b/services/audioflinger/DeviceEffectManager.h
@@ -183,7 +183,7 @@
void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused,
bool enabled __unused, bool threadLocked __unused) override {}
void resetVolume() override {}
- uint32_t strategy() const override { return 0; }
+ product_strategy_t strategy() const override { return static_cast<product_strategy_t>(0); }
int32_t activeTrackCnt() const override { return 0; }
void onEffectEnable(const sp<EffectBase>& effect __unused) override {}
void onEffectDisable(const sp<EffectBase>& effect __unused) override {}
diff --git a/services/audioflinger/Effects.cpp b/services/audioflinger/Effects.cpp
index 56d32a6..392d339 100644
--- a/services/audioflinger/Effects.cpp
+++ b/services/audioflinger/Effects.cpp
@@ -238,7 +238,7 @@
bool doEnable = false;
bool enabled = false;
audio_io_handle_t io = AUDIO_IO_HANDLE_NONE;
- uint32_t strategy = PRODUCT_STRATEGY_NONE;
+ product_strategy_t strategy = PRODUCT_STRATEGY_NONE;
{
Mutex::Autolock _l(mLock);
@@ -2985,7 +2985,7 @@
}
-uint32_t AudioFlinger::EffectChain::EffectCallback::strategy() const {
+product_strategy_t AudioFlinger::EffectChain::EffectCallback::strategy() const {
sp<EffectChain> c = chain().promote();
if (c == nullptr) {
return PRODUCT_STRATEGY_NONE;
diff --git a/services/audioflinger/Effects.h b/services/audioflinger/Effects.h
index 139c049..8e82d53 100644
--- a/services/audioflinger/Effects.h
+++ b/services/audioflinger/Effects.h
@@ -59,7 +59,7 @@
virtual bool updateOrphanEffectChains(const sp<EffectBase>& effect) = 0;
// Methods usually implemented with help from EffectChain: pay attention to mutex locking order
- virtual uint32_t strategy() const = 0;
+ virtual product_strategy_t strategy() const = 0;
virtual int32_t activeTrackCnt() const = 0;
virtual void resetVolume() = 0;
@@ -465,8 +465,8 @@
void decActiveTrackCnt() { android_atomic_dec(&mActiveTrackCnt); }
int32_t activeTrackCnt() const { return android_atomic_acquire_load(&mActiveTrackCnt); }
- uint32_t strategy() const { return mStrategy; }
- void setStrategy(uint32_t strategy)
+ product_strategy_t strategy() const { return mStrategy; }
+ void setStrategy(product_strategy_t strategy)
{ mStrategy = strategy; }
// suspend or restore effects of the specified type. The number of suspend requests is counted
@@ -556,7 +556,7 @@
void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect,
bool enabled, bool threadLocked) override;
void resetVolume() override;
- uint32_t strategy() const override;
+ product_strategy_t strategy() const override;
int32_t activeTrackCnt() const override;
void onEffectEnable(const sp<EffectBase>& effect) override;
void onEffectDisable(const sp<EffectBase>& effect) override;
@@ -626,7 +626,7 @@
uint32_t mRightVolume; // previous volume on right channel
uint32_t mNewLeftVolume; // new volume on left channel
uint32_t mNewRightVolume; // new volume on right channel
- uint32_t mStrategy; // strategy for this effect chain
+ product_strategy_t mStrategy; // strategy for this effect chain
// mSuspendedEffects lists all effects currently suspended in the chain.
// Use effect type UUID timelow field as key. There is no real risk of identical
// timeLow fields among effect type UUIDs.
@@ -706,7 +706,7 @@
void checkSuspendOnEffectEnabled(const sp<EffectBase>& effect __unused,
bool enabled __unused, bool threadLocked __unused) override {}
void resetVolume() override {}
- uint32_t strategy() const override { return 0; }
+ product_strategy_t strategy() const override { return static_cast<product_strategy_t>(0); }
int32_t activeTrackCnt() const override { return 0; }
void onEffectEnable(const sp<EffectBase>& effect __unused) override {}
void onEffectDisable(const sp<EffectBase>& effect __unused) override {}
diff --git a/services/audioflinger/Threads.cpp b/services/audioflinger/Threads.cpp
index 7e1c67e..1f5b8d2 100644
--- a/services/audioflinger/Threads.cpp
+++ b/services/audioflinger/Threads.cpp
@@ -2345,11 +2345,11 @@
// all tracks in same audio session must share the same routing strategy otherwise
// conflicts will happen when tracks are moved from one output to another by audio policy
// manager
- uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
+ product_strategy_t strategy = AudioSystem::getStrategyForStream(streamType);
for (size_t i = 0; i < mTracks.size(); ++i) {
sp<Track> t = mTracks[i];
if (t != 0 && t->isExternalTrack()) {
- uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
+ product_strategy_t actual = AudioSystem::getStrategyForStream(t->streamType());
if (sessionId == t->sessionId() && strategy != actual) {
ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
strategy, actual);
@@ -2999,7 +2999,7 @@
}
}
-uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
+product_strategy_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
{
// session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
// it is moved to correct output by audio policy manager when A2DP is connected or disconnected
diff --git a/services/audioflinger/Threads.h b/services/audioflinger/Threads.h
index cf4bb8a..c974252 100644
--- a/services/audioflinger/Threads.h
+++ b/services/audioflinger/Threads.h
@@ -435,8 +435,10 @@
// the value returned by default implementation is not important as the
// strategy is only meaningful for PlaybackThread which implements this method
- virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused)
- { return 0; }
+ virtual product_strategy_t getStrategyForSession_l(
+ audio_session_t sessionId __unused) {
+ return static_cast<product_strategy_t>(0);
+ }
// check if some effects must be suspended/restored when an effect is enabled
// or disabled
@@ -924,7 +926,7 @@
uint32_t hasAudioSession_l(audio_session_t sessionId) const override {
return ThreadBase::hasAudioSession_l(sessionId, mTracks);
}
- virtual uint32_t getStrategyForSession_l(audio_session_t sessionId);
+ virtual product_strategy_t getStrategyForSession_l(audio_session_t sessionId);
virtual status_t setSyncEvent(const sp<SyncEvent>& event);
diff --git a/services/audiopolicy/AudioPolicyInterface.h b/services/audiopolicy/AudioPolicyInterface.h
index e52ad5e..630c423 100644
--- a/services/audiopolicy/AudioPolicyInterface.h
+++ b/services/audiopolicy/AudioPolicyInterface.h
@@ -191,7 +191,7 @@
int &index) = 0;
// return the strategy corresponding to a given stream type
- virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;
+ virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) = 0;
// return the enabled output devices for the given stream type
virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;
@@ -204,7 +204,7 @@
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
virtual status_t registerEffect(const effect_descriptor_t *desc,
audio_io_handle_t io,
- uint32_t strategy,
+ product_strategy_t strategy,
int session,
int id) = 0;
virtual status_t unregisterEffect(int id) = 0;
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
index 65bae77..c0a8f9d 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
@@ -2852,7 +2852,7 @@
status_t AudioPolicyManager::registerEffect(const effect_descriptor_t *desc,
audio_io_handle_t io,
- uint32_t strategy,
+ product_strategy_t strategy,
int session,
int id)
{
diff --git a/services/audiopolicy/managerdefault/AudioPolicyManager.h b/services/audiopolicy/managerdefault/AudioPolicyManager.h
index eba0c44..3c55b63 100644
--- a/services/audiopolicy/managerdefault/AudioPolicyManager.h
+++ b/services/audiopolicy/managerdefault/AudioPolicyManager.h
@@ -180,7 +180,7 @@
const DeviceTypeSet& deviceTypes) const;
// return the strategy corresponding to a given stream type
- virtual uint32_t getStrategyForStream(audio_stream_type_t stream)
+ virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream)
{
return streamToStrategy(stream);
}
@@ -200,7 +200,7 @@
virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL);
virtual status_t registerEffect(const effect_descriptor_t *desc,
audio_io_handle_t io,
- uint32_t strategy,
+ product_strategy_t strategy,
int session,
int id);
virtual status_t unregisterEffect(int id);
diff --git a/services/audiopolicy/service/Android.bp b/services/audiopolicy/service/Android.bp
index ceddb7e..8cb1b59 100644
--- a/services/audiopolicy/service/Android.bp
+++ b/services/audiopolicy/service/Android.bp
@@ -17,6 +17,7 @@
"libaudioclient",
"libaudioclient_aidl_conversion",
"libaudiofoundation",
+ "libaudiopolicy",
"libaudiopolicymanager",
"libaudioutils",
"libbinder",
@@ -32,7 +33,8 @@
"audioclient-types-aidl-unstable-cpp",
"audioflinger-aidl-unstable-cpp",
"audiopolicy-aidl-unstable-cpp",
- "capture_state_listener-aidl-cpp",
+ "audiopolicy-types-aidl-unstable-cpp",
+ "capture_state_listener-aidl-unstable-cpp",
],
static_libs: [
diff --git a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
index 66f9fbd..fed88a4 100644
--- a/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
+++ b/services/audiopolicy/service/AudioPolicyInterfaceImpl.cpp
@@ -19,11 +19,29 @@
#include "AudioPolicyService.h"
#include "TypeConverter.h"
-#include <media/MediaMetricsItem.h>
+#include <media/AidlConversion.h>
#include <media/AudioPolicy.h>
+#include <media/AudioValidator.h>
+#include <media/MediaMetricsItem.h>
+#include <media/PolicyAidlConversion.h>
#include <utils/Log.h>
+#define VALUE_OR_RETURN_BINDER_STATUS(x) \
+ ({ auto _tmp = (x); \
+ if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
+ std::move(_tmp.value()); })
+
+#define RETURN_IF_BINDER_ERROR(x) \
+ { \
+ binder::Status _tmp = (x); \
+ if (!_tmp.isOk()) return _tmp; \
+ }
+
+#define MAX_ITEMS_PER_LIST 1024
+
namespace android {
+using binder::Status;
+using aidl_utils::binderStatusFromStatusT;
const std::vector<audio_usage_t>& SYSTEM_USAGES = {
AUDIO_USAGE_CALL_ASSISTANT,
@@ -74,71 +92,94 @@
mAudioPolicyManager->onNewAudioModulesAvailable();
}
-status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
-{
+Status AudioPolicyService::setDeviceConnectionState(
+ const media::AudioDevice& deviceAidl,
+ media::AudioPolicyDeviceState stateAidl,
+ const std::string& deviceNameAidl,
+ media::audio::common::AudioFormat encodedFormatAidl) {
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
+ audio_policy_dev_state_t state = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(stateAidl));
+ audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
ALOGV("setDeviceConnectionState()");
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setDeviceConnectionState(device, state,
- device_address, device_name, encodedFormat);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setDeviceConnectionState(device, state,
+ deviceAidl.address.c_str(),
+ deviceNameAidl.c_str(),
+ encodedFormat));
}
-audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState(
- audio_devices_t device,
- const char *device_address)
-{
+Status AudioPolicyService::getDeviceConnectionState(const media::AudioDevice& deviceAidl,
+ media::AudioPolicyDeviceState* _aidl_return) {
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
if (mAudioPolicyManager == NULL) {
- return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
+ AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
+ return Status::ok();
}
AutoCallerClear acc;
- return mAudioPolicyManager->getDeviceConnectionState(device,
- device_address);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
+ mAudioPolicyManager->getDeviceConnectionState(device,
+ deviceAidl.address.c_str())));
+ return Status::ok();
}
-status_t AudioPolicyService::handleDeviceConfigChange(audio_devices_t device,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat)
-{
+Status AudioPolicyService::handleDeviceConfigChange(
+ const media::AudioDevice& deviceAidl,
+ const std::string& deviceNameAidl,
+ media::audio::common::AudioFormat encodedFormatAidl) {
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
+ audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
ALOGV("handleDeviceConfigChange()");
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->handleDeviceConfigChange(device, device_address,
- device_name, encodedFormat);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->handleDeviceConfigChange(device, deviceAidl.address.c_str(),
+ deviceNameAidl.c_str(), encodedFormat));
}
-status_t AudioPolicyService::setPhoneState(audio_mode_t state, uid_t uid)
+Status AudioPolicyService::setPhoneState(media::AudioMode stateAidl, int32_t uidAidl)
{
+ audio_mode_t state = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioMode_audio_mode_t(stateAidl));
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (uint32_t(state) >= AUDIO_MODE_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
ALOGV("setPhoneState()");
@@ -154,85 +195,116 @@
mAudioPolicyManager->setPhoneState(state);
mPhoneState = state;
mPhoneStateOwnerUid = uid;
- return NO_ERROR;
+ return Status::ok();
}
-audio_mode_t AudioPolicyService::getPhoneState()
-{
+Status AudioPolicyService::getPhoneState(media::AudioMode* _aidl_return) {
Mutex::Autolock _l(mLock);
- return mPhoneState;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_mode_t_AudioMode(mPhoneState));
+ return Status::ok();
}
-status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage,
- audio_policy_forced_cfg_t config)
+Status AudioPolicyService::setForceUse(media::AudioPolicyForceUse usageAidl,
+ media::AudioPolicyForcedConfig configAidl)
{
+ audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
+ audio_policy_forced_cfg_t config = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
ALOGV("setForceUse()");
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
mAudioPolicyManager->setForceUse(usage, config);
- return NO_ERROR;
+ return Status::ok();
}
-audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage)
-{
+Status AudioPolicyService::getForceUse(media::AudioPolicyForceUse usageAidl,
+ media::AudioPolicyForcedConfig* _aidl_return) {
+ audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
+
if (mAudioPolicyManager == NULL) {
- return AUDIO_POLICY_FORCE_NONE;
+ return binderStatusFromStatusT(NO_INIT);
}
if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
- return AUDIO_POLICY_FORCE_NONE;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(AUDIO_POLICY_FORCE_NONE));
+ return Status::ok();
}
AutoCallerClear acc;
- return mAudioPolicyManager->getForceUse(usage);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
+ mAudioPolicyManager->getForceUse(usage)));
+ return Status::ok();
}
-audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream)
+Status AudioPolicyService::getOutput(media::AudioStreamType streamAidl, int32_t* _aidl_return)
{
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return AUDIO_IO_HANDLE_NONE;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(AUDIO_IO_HANDLE_NONE));
+ return Status::ok();
}
if (mAudioPolicyManager == NULL) {
- return AUDIO_IO_HANDLE_NONE;
+ return binderStatusFromStatusT(NO_INIT);
}
ALOGV("getOutput()");
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getOutput(stream);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutput(stream)));
+ return Status::ok();
}
-status_t AudioPolicyService::getOutputForAttr(audio_attributes_t *attr,
- audio_io_handle_t *output,
- audio_session_t session,
- audio_stream_type_t *stream,
- pid_t pid,
- uid_t uid,
- const audio_config_t *config,
- audio_output_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId,
- std::vector<audio_io_handle_t> *secondaryOutputs)
+Status AudioPolicyService::getOutputForAttr(const media::AudioAttributesInternal& attrAidl,
+ int32_t sessionAidl,
+ int32_t pidAidl,
+ int32_t uidAidl,
+ const media::AudioConfig& configAidl,
+ int32_t flagsAidl,
+ media::GetOutputForAttrResponse* _aidl_return)
{
+ audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_session_t(sessionAidl));
+ audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
+ pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+ audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioConfig_audio_config_t(configAidl));
+ audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_output_flags_t_mask(flagsAidl));
+ audio_io_handle_t output;
+ audio_port_handle_t selectedDeviceId;
+ audio_port_handle_t portId;
+ std::vector<audio_io_handle_t> secondaryOutputs;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
- status_t result = validateUsage(attr->usage, pid, uid);
- if (result != NO_ERROR) {
- return result;
- }
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
ALOGV("%s()", __func__);
Mutex::Autolock _l(mLock);
@@ -244,20 +316,22 @@
uid = callingUid;
}
if (!mPackageManager.allowPlaybackCapture(uid)) {
- attr->flags = static_cast<audio_flags_mask_t>(attr->flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
+ attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
}
- if (((attr->flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
+ if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
&& !bypassInterruptionPolicyAllowed(pid, uid)) {
- attr->flags = static_cast<audio_flags_mask_t>(
- attr->flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
+ attr.flags = static_cast<audio_flags_mask_t>(
+ attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
}
AutoCallerClear acc;
AudioPolicyInterface::output_type_t outputType;
- result = mAudioPolicyManager->getOutputForAttr(attr, output, session, stream, uid,
- config,
- &flags, selectedDeviceId, portId,
- secondaryOutputs,
- &outputType);
+ status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
+ &stream,
+ uid,
+ &config,
+ &flags, &selectedDeviceId, &portId,
+ &secondaryOutputs,
+ &outputType);
// FIXME: Introduce a way to check for the the telephony device before opening the output
if (result == NO_ERROR) {
@@ -287,11 +361,24 @@
}
if (result == NO_ERROR) {
- sp <AudioPlaybackClient> client =
- new AudioPlaybackClient(*attr, *output, uid, pid, session, *portId, *selectedDeviceId, *stream);
- mAudioPlaybackClients.add(*portId, client);
+ sp<AudioPlaybackClient> client =
+ new AudioPlaybackClient(attr, output, uid, pid, session, portId, selectedDeviceId,
+ stream);
+ mAudioPlaybackClients.add(portId, client);
+
+ _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(output));
+ _aidl_return->stream = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
+ _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
+ _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(portId));
+ _aidl_return->secondaryOutputs = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<int32_t>>(secondaryOutputs,
+ legacy2aidl_audio_io_handle_t_int32_t));
}
- return result;
+ return binderStatusFromStatusT(result);
}
void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
@@ -309,10 +396,12 @@
effects = mAudioPolicyEffects;
}
-status_t AudioPolicyService::startOutput(audio_port_handle_t portId)
+Status AudioPolicyService::startOutput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
ALOGV("startOutput()");
sp<AudioPlaybackClient> client;
@@ -334,17 +423,19 @@
if (status == NO_ERROR) {
client->active = true;
}
- return status;
+ return binderStatusFromStatusT(status);
}
-status_t AudioPolicyService::stopOutput(audio_port_handle_t portId)
+Status AudioPolicyService::stopOutput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
ALOGV("stopOutput()");
mOutputCommandThread->stopOutputCommand(portId);
- return NO_ERROR;
+ return Status::ok();
}
status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
@@ -372,13 +463,16 @@
return status;
}
-void AudioPolicyService::releaseOutput(audio_port_handle_t portId)
+Status AudioPolicyService::releaseOutput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
if (mAudioPolicyManager == NULL) {
- return;
+ return binderStatusFromStatusT(NO_INIT);
}
ALOGV("releaseOutput()");
mOutputCommandThread->releaseOutputCommand(portId);
+ return Status::ok();
}
void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
@@ -401,28 +495,44 @@
mAudioPolicyManager->releaseOutput(portId);
}
-status_t AudioPolicyService::getInputForAttr(const audio_attributes_t *attr,
- audio_io_handle_t *input,
- audio_unique_id_t riid,
- audio_session_t session,
- pid_t pid,
- uid_t uid,
- const String16& opPackageName,
- const audio_config_base_t *config,
- audio_input_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId)
-{
+Status AudioPolicyService::getInputForAttr(const media::AudioAttributesInternal& attrAidl,
+ int32_t inputAidl,
+ int32_t riidAidl,
+ int32_t sessionAidl,
+ int32_t pidAidl,
+ int32_t uidAidl,
+ const std::string& opPackageNameAidl,
+ const media::AudioConfigBase& configAidl,
+ int32_t flagsAidl,
+ media::GetInputForAttrResponse* _aidl_return) {
+ audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ audio_io_handle_t input = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
+ audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
+ audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_session_t(sessionAidl));
+ pid_t pid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_pid_t(pidAidl));
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+ String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_string_view_String16(opPackageNameAidl));
+ audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
+ audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_input_flags_t_mask(flagsAidl));
+ audio_port_handle_t selectedDeviceId;
+ audio_port_handle_t portId;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
- status_t result = validateUsage(attr->usage, pid, uid);
- if (result != NO_ERROR) {
- return result;
- }
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, pid, uid)));
- audio_source_t inputSource = attr->source;
+ audio_source_t inputSource = attr.source;
if (inputSource == AUDIO_SOURCE_DEFAULT) {
inputSource = AUDIO_SOURCE_MIC;
}
@@ -433,7 +543,7 @@
&& inputSource != AUDIO_SOURCE_HOTWORD
&& inputSource != AUDIO_SOURCE_FM_TUNER
&& inputSource != AUDIO_SOURCE_ECHO_REFERENCE)) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
bool updatePid = (pid == -1);
@@ -457,10 +567,10 @@
// Capturing from FM_TUNER source is controlled by captureTunerAudioInputAllowed() and
// captureAudioOutputAllowed() (deprecated) as this does not affect users privacy
// as does capturing from an actual microphone.
- if (!(recordingAllowed(opPackageName, pid, uid) || attr->source == AUDIO_SOURCE_FM_TUNER)) {
+ if (!(recordingAllowed(opPackageName, pid, uid) || attr.source == AUDIO_SOURCE_FM_TUNER)) {
ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
__func__, uid, pid);
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
bool canCaptureOutput = captureAudioOutputAllowed(pid, uid);
@@ -469,18 +579,18 @@
inputSource == AUDIO_SOURCE_VOICE_CALL ||
inputSource == AUDIO_SOURCE_ECHO_REFERENCE)
&& !canCaptureOutput) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (inputSource == AUDIO_SOURCE_FM_TUNER
&& !captureTunerAudioInputAllowed(pid, uid)
&& !canCaptureOutput) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
bool canCaptureHotword = captureHotwordAllowed(opPackageName, pid, uid);
if ((inputSource == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
sp<AudioPolicyEffects>audioPolicyEffects;
@@ -492,10 +602,10 @@
{
AutoCallerClear acc;
// the audio_in_acoustics_t parameter is ignored by get_input()
- status = mAudioPolicyManager->getInputForAttr(attr, input, riid, session, uid,
- config,
- flags, selectedDeviceId,
- &inputType, portId);
+ status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session, uid,
+ &config,
+ flags, &selectedDeviceId,
+ &inputType, &portId);
}
audioPolicyEffects = mAudioPolicyEffects;
@@ -531,25 +641,32 @@
if (status != NO_ERROR) {
if (status == PERMISSION_DENIED) {
AutoCallerClear acc;
- mAudioPolicyManager->releaseInput(*portId);
+ mAudioPolicyManager->releaseInput(portId);
}
- return status;
+ return binderStatusFromStatusT(status);
}
- sp<AudioRecordClient> client = new AudioRecordClient(*attr, *input, uid, pid, session, *portId,
- *selectedDeviceId, opPackageName,
+ sp<AudioRecordClient> client = new AudioRecordClient(attr, input, uid, pid, session, portId,
+ selectedDeviceId, opPackageName,
canCaptureOutput, canCaptureHotword);
- mAudioRecordClients.add(*portId, client);
+ mAudioRecordClients.add(portId, client);
}
if (audioPolicyEffects != 0) {
// create audio pre processors according to input source
- status_t status = audioPolicyEffects->addInputEffects(*input, inputSource, session);
+ status_t status = audioPolicyEffects->addInputEffects(input, inputSource, session);
if (status != NO_ERROR && status != ALREADY_EXISTS) {
- ALOGW("Failed to add effects on input %d", *input);
+ ALOGW("Failed to add effects on input %d", input);
}
}
- return NO_ERROR;
+
+ _aidl_return->input = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(input));
+ _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
+ _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return Status::ok();
}
std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
@@ -562,10 +679,13 @@
return {};
}
-status_t AudioPolicyService::startInput(audio_port_handle_t portId)
+Status AudioPolicyService::startInput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
sp<AudioRecordClient> client;
{
@@ -573,7 +693,7 @@
ssize_t index = mAudioRecordClients.indexOfKey(portId);
if (index < 0) {
- return INVALID_OPERATION;
+ return binderStatusFromStatusT(INVALID_OPERATION);
}
client = mAudioRecordClients.valueAt(index);
}
@@ -584,7 +704,7 @@
|| client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
ALOGE("%s permission denied: recording not allowed for uid %d pid %d",
__func__, client->uid, client->pid);
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
Mutex::Autolock _l(mLock);
@@ -672,20 +792,23 @@
client->attributes.source);
}
- return status;
+ return binderStatusFromStatusT(status);
}
-status_t AudioPolicyService::stopInput(audio_port_handle_t portId)
+Status AudioPolicyService::stopInput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
ssize_t index = mAudioRecordClients.indexOfKey(portId);
if (index < 0) {
- return INVALID_OPERATION;
+ return binderStatusFromStatusT(INVALID_OPERATION);
}
sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
@@ -698,13 +821,16 @@
finishRecording(client->opPackageName, client->uid,
client->attributes.source);
AutoCallerClear acc;
- return mAudioPolicyManager->stopInput(portId);
+ return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
}
-void AudioPolicyService::releaseInput(audio_port_handle_t portId)
+Status AudioPolicyService::releaseInput(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
if (mAudioPolicyManager == NULL) {
- return;
+ return binderStatusFromStatusT(NO_INIT);
}
sp<AudioPolicyEffects>audioPolicyEffects;
sp<AudioRecordClient> client;
@@ -713,7 +839,7 @@
audioPolicyEffects = mAudioPolicyEffects;
ssize_t index = mAudioRecordClients.indexOfKey(portId);
if (index < 0) {
- return;
+ return Status::ok();
}
client = mAudioRecordClients.valueAt(index);
@@ -727,7 +853,7 @@
mAudioRecordClients.removeItem(portId);
}
if (client == 0) {
- return;
+ return Status::ok();
}
if (audioPolicyEffects != 0) {
// release audio processors from the input
@@ -741,239 +867,354 @@
AutoCallerClear acc;
mAudioPolicyManager->releaseInput(portId);
}
+ return Status::ok();
}
-status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream,
- int indexMin,
- int indexMax)
-{
+Status AudioPolicyService::initStreamVolume(media::AudioStreamType streamAidl,
+ int32_t indexMinAidl,
+ int32_t indexMaxAidl) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ int indexMin = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMinAidl));
+ int indexMax = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMaxAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
- return NO_ERROR;
+ return binderStatusFromStatusT(NO_ERROR);
}
-status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device)
-{
+Status AudioPolicyService::setStreamVolumeIndex(media::AudioStreamType streamAidl,
+ int32_t deviceAidl, int32_t indexAidl) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setStreamVolumeIndex(stream,
- index,
- device);
+ return binderStatusFromStatusT(mAudioPolicyManager->setStreamVolumeIndex(stream,
+ index,
+ device));
}
-status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream,
- int *index,
- audio_devices_t device)
-{
+Status AudioPolicyService::getStreamVolumeIndex(media::AudioStreamType streamAidl,
+ int32_t deviceAidl, int32_t* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+ int index;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getStreamVolumeIndex(stream,
- index,
- device);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getStreamVolumeIndex(stream, &index, device)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+ return Status::ok();
}
-status_t AudioPolicyService::setVolumeIndexForAttributes(const audio_attributes_t &attributes,
- int index, audio_devices_t device)
-{
+Status AudioPolicyService::setVolumeIndexForAttributes(
+ const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t indexAidl) {
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device));
}
-status_t AudioPolicyService::getVolumeIndexForAttributes(const audio_attributes_t &attributes,
- int &index, audio_devices_t device)
-{
+Status AudioPolicyService::getVolumeIndexForAttributes(
+ const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t* _aidl_return) {
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+ int index;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+ return Status::ok();
}
-status_t AudioPolicyService::getMinVolumeIndexForAttributes(const audio_attributes_t &attributes,
- int &index)
-{
+Status AudioPolicyService::getMinVolumeIndexForAttributes(
+ const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ int index;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+ return Status::ok();
}
-status_t AudioPolicyService::getMaxVolumeIndexForAttributes(const audio_attributes_t &attributes,
- int &index)
-{
+Status AudioPolicyService::getMaxVolumeIndexForAttributes(
+ const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
+ int index;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
+ return Status::ok();
}
-uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream)
-{
+Status AudioPolicyService::getStrategyForStream(media::AudioStreamType streamAidl,
+ int32_t* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return PRODUCT_STRATEGY_NONE;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertReinterpret<int32_t>(PRODUCT_STRATEGY_NONE));
+ return Status::ok();
}
if (mAudioPolicyManager == NULL) {
- return PRODUCT_STRATEGY_NONE;
+ return binderStatusFromStatusT(NO_INIT);
}
+
// DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
AutoCallerClear acc;
- return mAudioPolicyManager->getStrategyForStream(stream);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_product_strategy_t_int32_t(
+ mAudioPolicyManager->getStrategyForStream(stream)));
+ return Status::ok();
}
//audio policy: use audio_device_t appropriately
-audio_devices_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream)
-{
+Status AudioPolicyService::getDevicesForStream(media::AudioStreamType streamAidl,
+ int32_t* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return AUDIO_DEVICE_NONE;
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_devices_t_int32_t(AUDIO_DEVICE_NONE));
+ return Status::ok();
}
if (mAudioPolicyManager == NULL) {
- return AUDIO_DEVICE_NONE;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getDevicesForStream(stream);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_devices_t_int32_t(mAudioPolicyManager->getDevicesForStream(stream)));
+ return Status::ok();
}
-status_t AudioPolicyService::getDevicesForAttributes(const AudioAttributes &aa,
- AudioDeviceTypeAddrVector *devices) const
+Status AudioPolicyService::getDevicesForAttributes(const media::AudioAttributesEx& attrAidl,
+ std::vector<media::AudioDevice>* _aidl_return)
{
+ AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesEx_AudioAttributes(attrAidl));
+ AudioDeviceTypeAddrVector devices;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), devices);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), &devices)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return Status::ok();
}
-audio_io_handle_t AudioPolicyService::getOutputForEffect(const effect_descriptor_t *desc)
-{
- // FIXME change return type to status_t, and return NO_INIT here
+Status AudioPolicyService::getOutputForEffect(const media::EffectDescriptor& descAidl,
+ int32_t* _aidl_return) {
+ effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateEffectDescriptor(desc, "73126106")));
+
if (mAudioPolicyManager == NULL) {
- return 0;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getOutputForEffect(desc);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutputForEffect(&desc)));
+ return Status::ok();
}
-status_t AudioPolicyService::registerEffect(const effect_descriptor_t *desc,
- audio_io_handle_t io,
- uint32_t strategy,
- audio_session_t session,
- int id)
-{
+Status AudioPolicyService::registerEffect(const media::EffectDescriptor& descAidl, int32_t ioAidl,
+ int32_t strategyAidl, int32_t sessionAidl,
+ int32_t idAidl) {
+ effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
+ audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
+ product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+ audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_session_t(sessionAidl));
+ int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateEffectDescriptor(desc, "73126106")));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->registerEffect(desc, io, strategy, session, id);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->registerEffect(&desc, io, strategy, session, id));
}
-status_t AudioPolicyService::unregisterEffect(int id)
+Status AudioPolicyService::unregisterEffect(int32_t idAidl)
{
+ int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->unregisterEffect(id);
+ return binderStatusFromStatusT(mAudioPolicyManager->unregisterEffect(id));
}
-status_t AudioPolicyService::setEffectEnabled(int id, bool enabled)
+Status AudioPolicyService::setEffectEnabled(int32_t idAidl, bool enabled)
{
+ int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setEffectEnabled(id, enabled);
+ return binderStatusFromStatusT(mAudioPolicyManager->setEffectEnabled(id, enabled));
}
-status_t AudioPolicyService::moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io)
+Status AudioPolicyService::moveEffectsToIo(const std::vector<int32_t>& idsAidl, int32_t ioAidl)
+
{
+ const std::vector<int>& ids = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<int>>(idsAidl, convertReinterpret<int, int32_t>));
+ audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
+ if (ids.size() > MAX_ITEMS_PER_LIST) {
+ return binderStatusFromStatusT(BAD_VALUE);
+ }
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->moveEffectsToIo(ids, io);
+ return binderStatusFromStatusT(mAudioPolicyManager->moveEffectsToIo(ids, io));
}
-bool AudioPolicyService::isStreamActive(audio_stream_type_t stream, uint32_t inPastMs) const
-{
+Status AudioPolicyService::isStreamActive(media::AudioStreamType streamAidl, int32_t inPastMsAidl,
+ bool* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
+
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return false;
+ *_aidl_return = false;
+ return Status::ok();
}
if (mAudioPolicyManager == NULL) {
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->isStreamActive(stream, inPastMs);
+ *_aidl_return = mAudioPolicyManager->isStreamActive(stream, inPastMs);
+ return Status::ok();
}
-bool AudioPolicyService::isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs) const
-{
+Status AudioPolicyService::isStreamActiveRemotely(media::AudioStreamType streamAidl,
+ int32_t inPastMsAidl,
+ bool* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
+
if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
- return false;
+ *_aidl_return = false;
+ return Status::ok();
}
if (mAudioPolicyManager == NULL) {
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
+ *_aidl_return = mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
+ return Status::ok();
}
-bool AudioPolicyService::isSourceActive(audio_source_t source) const
-{
+Status AudioPolicyService::isSourceActive(media::AudioSourceType sourceAidl, bool* _aidl_return) {
+ audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
if (mAudioPolicyManager == NULL) {
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->isSourceActive(source);
+ *_aidl_return = mAudioPolicyManager->isSourceActive(source);
+ return Status::ok();
}
status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
@@ -992,246 +1233,378 @@
return OK;
}
-status_t AudioPolicyService::queryDefaultPreProcessing(audio_session_t audioSession,
- effect_descriptor_t *descriptors,
- uint32_t *count)
-{
- sp<AudioPolicyEffects>audioPolicyEffects;
- status_t status = getAudioPolicyEffects(audioPolicyEffects);
- if (status != OK) {
- *count = 0;
- return status;
+Status AudioPolicyService::queryDefaultPreProcessing(
+ int32_t audioSessionAidl,
+ media::Int* countAidl,
+ std::vector<media::EffectDescriptor>* _aidl_return) {
+ audio_session_t audioSession = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_session_t(audioSessionAidl));
+ uint32_t count = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(countAidl->value));
+ if (count > AudioEffect::kMaxPreProcessing) {
+ count = AudioEffect::kMaxPreProcessing;
}
- return audioPolicyEffects->queryDefaultInputEffects(
- (audio_session_t)audioSession, descriptors, count);
+ uint32_t countReq = count;
+ std::unique_ptr<effect_descriptor_t[]> descriptors(new effect_descriptor_t[count]);
+
+ sp<AudioPolicyEffects> audioPolicyEffects;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->queryDefaultInputEffects(
+ (audio_session_t) audioSession, descriptors.get(), &count)));
+ countReq = std::min(count, countReq);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(descriptors.get(), descriptors.get() + countReq,
+ std::back_inserter(*_aidl_return),
+ legacy2aidl_effect_descriptor_t_EffectDescriptor)));
+ countAidl->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(count));
+ return Status::ok();
}
-status_t AudioPolicyService::addSourceDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_source_t source,
- audio_unique_id_t* id)
-{
+Status AudioPolicyService::addSourceDefaultEffect(const media::AudioUuid& typeAidl,
+ const std::string& opPackageNameAidl,
+ const media::AudioUuid& uuidAidl,
+ int32_t priority,
+ media::AudioSourceType sourceAidl,
+ int32_t* _aidl_return) {
+ effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
+ String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_string_view_String16(opPackageNameAidl));
+ effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
+ audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
+ audio_unique_id_t id;
+
sp<AudioPolicyEffects>audioPolicyEffects;
- status_t status = getAudioPolicyEffects(audioPolicyEffects);
- if (status != OK) {
- return status;
- }
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
if (!modifyDefaultAudioEffectsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
- return audioPolicyEffects->addSourceDefaultEffect(
- type, opPackageName, uuid, priority, source, id);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addSourceDefaultEffect(
+ &type, opPackageName, &uuid, priority, source, &id)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+ return Status::ok();
}
-status_t AudioPolicyService::addStreamDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_usage_t usage,
- audio_unique_id_t* id)
-{
- sp<AudioPolicyEffects>audioPolicyEffects;
- status_t status = getAudioPolicyEffects(audioPolicyEffects);
- if (status != OK) {
- return status;
- }
+Status AudioPolicyService::addStreamDefaultEffect(const media::AudioUuid& typeAidl,
+ const std::string& opPackageNameAidl,
+ const media::AudioUuid& uuidAidl,
+ int32_t priority, media::AudioUsage usageAidl,
+ int32_t* _aidl_return) {
+ effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
+ String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_string_view_String16(opPackageNameAidl));
+ effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
+ audio_usage_t usage = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioUsage_audio_usage_t(usageAidl));
+ audio_unique_id_t id;
+
+ sp<AudioPolicyEffects> audioPolicyEffects;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
if (!modifyDefaultAudioEffectsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
- return audioPolicyEffects->addStreamDefaultEffect(
- type, opPackageName, uuid, priority, usage, id);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addStreamDefaultEffect(
+ &type, opPackageName, &uuid, priority, usage, &id)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
+ return Status::ok();
}
-status_t AudioPolicyService::removeSourceDefaultEffect(audio_unique_id_t id)
+Status AudioPolicyService::removeSourceDefaultEffect(int32_t idAidl)
{
+ audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_unique_id_t(idAidl));
sp<AudioPolicyEffects>audioPolicyEffects;
- status_t status = getAudioPolicyEffects(audioPolicyEffects);
- if (status != OK) {
- return status;
- }
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
if (!modifyDefaultAudioEffectsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
- return audioPolicyEffects->removeSourceDefaultEffect(id);
+ return binderStatusFromStatusT(audioPolicyEffects->removeSourceDefaultEffect(id));
}
-status_t AudioPolicyService::removeStreamDefaultEffect(audio_unique_id_t id)
+Status AudioPolicyService::removeStreamDefaultEffect(int32_t idAidl)
{
+ audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_unique_id_t(idAidl));
sp<AudioPolicyEffects>audioPolicyEffects;
- status_t status = getAudioPolicyEffects(audioPolicyEffects);
- if (status != OK) {
- return status;
- }
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
if (!modifyDefaultAudioEffectsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
- return audioPolicyEffects->removeStreamDefaultEffect(id);
+ return binderStatusFromStatusT(audioPolicyEffects->removeStreamDefaultEffect(id));
}
-status_t AudioPolicyService::setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages) {
+Status AudioPolicyService::setSupportedSystemUsages(
+ const std::vector<media::AudioUsage>& systemUsagesAidl) {
+ size_t size = systemUsagesAidl.size();
+ if (size > MAX_ITEMS_PER_LIST) {
+ size = MAX_ITEMS_PER_LIST;
+ }
+ std::vector<audio_usage_t> systemUsages;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(systemUsagesAidl.begin(), systemUsagesAidl.begin() + size,
+ std::back_inserter(systemUsages), aidl2legacy_AudioUsage_audio_usage_t)));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
[](audio_usage_t usage) { return isSystemUsage(usage); });
if (!areAllSystemUsages) {
- return BAD_VALUE;
+ return binderStatusFromStatusT(BAD_VALUE);
}
mSupportedSystemUsages = systemUsages;
- return NO_ERROR;
+ return Status::ok();
}
-status_t AudioPolicyService::setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy) {
+Status AudioPolicyService::setAllowedCapturePolicy(int32_t uidAidl, int32_t capturePolicyAidl) {
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+ audio_flags_mask_t capturePolicy = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_flags_mask_t_mask(capturePolicyAidl));
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
ALOGV("%s() mAudioPolicyManager == NULL", __func__);
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
- return mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy));
}
-audio_offload_mode_t AudioPolicyService::getOffloadSupport(const audio_offload_info_t& info)
-{
+Status AudioPolicyService::getOffloadSupport(const media::AudioOffloadInfo& infoAidl,
+ media::AudioOffloadMode* _aidl_return) {
+ audio_offload_info_t info = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioOffloadInfo_audio_offload_info_t(infoAidl));
if (mAudioPolicyManager == NULL) {
ALOGV("mAudioPolicyManager == NULL");
- return AUDIO_OFFLOAD_NOT_SUPPORTED;
+ return binderStatusFromStatusT(AUDIO_OFFLOAD_NOT_SUPPORTED);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getOffloadSupport(info);
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_offload_mode_t_AudioOffloadMode(
+ mAudioPolicyManager->getOffloadSupport(info)));
+ return Status::ok();
}
-bool AudioPolicyService::isDirectOutputSupported(const audio_config_base_t& config,
- const audio_attributes_t& attributes) {
+Status AudioPolicyService::isDirectOutputSupported(
+ const media::AudioConfigBase& configAidl,
+ const media::AudioAttributesInternal& attributesAidl,
+ bool* _aidl_return) {
+ audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "169572641")));
+
if (mAudioPolicyManager == NULL) {
ALOGV("mAudioPolicyManager == NULL");
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
- status_t result = validateUsage(attributes.usage);
- if (result != NO_ERROR) {
- return result;
- }
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->isDirectOutputSupported(config, attributes);
+ *_aidl_return = mAudioPolicyManager->isDirectOutputSupported(config, attributes);
+ return Status::ok();
}
-status_t AudioPolicyService::listAudioPorts(audio_port_role_t role,
- audio_port_type_t type,
- unsigned int *num_ports,
- struct audio_port_v7 *ports,
- unsigned int *generation)
-{
+Status AudioPolicyService::listAudioPorts(media::AudioPortRole roleAidl,
+ media::AudioPortType typeAidl, media::Int* count,
+ std::vector<media::AudioPort>* portsAidl,
+ int32_t* _aidl_return) {
+ audio_port_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPortRole_audio_port_role_t(roleAidl));
+ audio_port_type_t type = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPortType_audio_port_type_t(typeAidl));
+ unsigned int num_ports = VALUE_OR_RETURN_BINDER_STATUS(
+ convertIntegral<unsigned int>(count->value));
+ if (num_ports > MAX_ITEMS_PER_LIST) {
+ num_ports = MAX_ITEMS_PER_LIST;
+ }
+ unsigned int numPortsReq = num_ports;
+ std::unique_ptr<audio_port_v7[]> ports(new audio_port_v7[num_ports]);
+ unsigned int generation;
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->listAudioPorts(role, type, num_ports, ports, generation);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->listAudioPorts(role, type, &num_ports, ports.get(), &generation)));
+ numPortsReq = std::min(numPortsReq, num_ports);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(ports.get(), ports.get() + numPortsReq, std::back_inserter(*portsAidl),
+ legacy2aidl_audio_port_v7_AudioPort)));
+ count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_ports));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
+ return Status::ok();
}
-status_t AudioPolicyService::getAudioPort(struct audio_port_v7 *port)
-{
+Status AudioPolicyService::getAudioPort(const media::AudioPort& portAidl,
+ media::AudioPort* _aidl_return) {
+ audio_port_v7 port = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPort_audio_port_v7(portAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPort(port)));
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->getAudioPort(port);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(mAudioPolicyManager->getAudioPort(&port)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_v7_AudioPort(port));
+ return Status::ok();
}
-status_t AudioPolicyService::createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle)
-{
+Status AudioPolicyService::createAudioPatch(const media::AudioPatch& patchAidl, int32_t handleAidl,
+ int32_t* _aidl_return) {
+ audio_patch patch = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPatch_audio_patch(patchAidl));
+ audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(handleAidl));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPatch(patch)));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->createAudioPatch(patch, handle,
- IPCThreadState::self()->getCallingUid());
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->createAudioPatch(&patch, &handle,
+ IPCThreadState::self()->getCallingUid())));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
+ return Status::ok();
}
-status_t AudioPolicyService::releaseAudioPatch(audio_patch_handle_t handle)
+Status AudioPolicyService::releaseAudioPatch(int32_t handleAidl)
{
+ audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->releaseAudioPatch(handle,
- IPCThreadState::self()->getCallingUid());
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->releaseAudioPatch(handle,
+ IPCThreadState::self()->getCallingUid()));
}
-status_t AudioPolicyService::listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches,
- unsigned int *generation)
-{
+Status AudioPolicyService::listAudioPatches(media::Int* count,
+ std::vector<media::AudioPatch>* patchesAidl,
+ int32_t* _aidl_return) {
+ unsigned int num_patches = VALUE_OR_RETURN_BINDER_STATUS(
+ convertIntegral<unsigned int>(count->value));
+ if (num_patches > MAX_ITEMS_PER_LIST) {
+ num_patches = MAX_ITEMS_PER_LIST;
+ }
+ unsigned int numPatchesReq = num_patches;
+ std::unique_ptr<audio_patch[]> patches(new audio_patch[num_patches]);
+ unsigned int generation;
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->listAudioPatches(num_patches, patches, generation);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->listAudioPatches(&num_patches, patches.get(), &generation)));
+ numPatchesReq = std::min(numPatchesReq, num_patches);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(patches.get(), patches.get() + numPatchesReq,
+ std::back_inserter(*patchesAidl), legacy2aidl_audio_patch_AudioPatch)));
+ count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_patches));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
+ return Status::ok();
}
-status_t AudioPolicyService::setAudioPortConfig(const struct audio_port_config *config)
+Status AudioPolicyService::setAudioPortConfig(const media::AudioPortConfig& configAidl)
{
+ audio_port_config config = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPortConfig_audio_port_config(configAidl));
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(AudioValidator::validateAudioPortConfig(config)));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->setAudioPortConfig(config);
+ return binderStatusFromStatusT(mAudioPolicyManager->setAudioPortConfig(&config));
}
-status_t AudioPolicyService::acquireSoundTriggerSession(audio_session_t *session,
- audio_io_handle_t *ioHandle,
- audio_devices_t *device)
+Status AudioPolicyService::acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return)
{
+ audio_session_t session;
+ audio_io_handle_t ioHandle;
+ audio_devices_t device;
+
+ {
+ Mutex::Autolock _l(mLock);
+ if (mAudioPolicyManager == NULL) {
+ return binderStatusFromStatusT(NO_INIT);
+ }
+ AutoCallerClear acc;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->acquireSoundTriggerSession(&session, &ioHandle, &device)));
+ }
+
+ _aidl_return->session = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_session_t_int32_t(session));
+ _aidl_return->ioHandle = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
+ _aidl_return->device = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_audio_devices_t_int32_t(device));
+ return Status::ok();
+}
+
+Status AudioPolicyService::releaseSoundTriggerSession(int32_t sessionAidl)
+{
+ audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_session_t(sessionAidl));
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->acquireSoundTriggerSession(session, ioHandle, device);
+ return binderStatusFromStatusT(mAudioPolicyManager->releaseSoundTriggerSession(session));
}
-status_t AudioPolicyService::releaseSoundTriggerSession(audio_session_t session)
-{
- Mutex::Autolock _l(mLock);
- if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+Status AudioPolicyService::registerPolicyMixes(const std::vector<media::AudioMix>& mixesAidl,
+ bool registration) {
+ size_t size = mixesAidl.size();
+ if (size > MAX_MIXES_PER_POLICY) {
+ size = MAX_MIXES_PER_POLICY;
}
- AutoCallerClear acc;
- return mAudioPolicyManager->releaseSoundTriggerSession(session);
-}
+ Vector<AudioMix> mixes;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(mixesAidl.begin(), mixesAidl.begin() + size, std::back_inserter(mixes),
+ aidl2legacy_AudioMix)));
-status_t AudioPolicyService::registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration)
-{
Mutex::Autolock _l(mLock);
// loopback|render only need a MediaProjection (checked in caller AudioService.java)
bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
return !is_mix_loopback_render(mix.mRouteFlags); });
if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
// If one of the mixes has needCaptureVoiceCommunicationOutput set to true, then we
@@ -1247,352 +1620,519 @@
const pid_t callingPid = IPCThreadState::self()->getCallingPid();
if (needCaptureMediaOutput && !captureMediaOutputAllowed(callingPid, callingUid)) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (needCaptureVoiceCommunicationOutput &&
!captureVoiceCommunicationOutputAllowed(callingPid, callingUid)) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
if (registration) {
- return mAudioPolicyManager->registerPolicyMixes(mixes);
+ return binderStatusFromStatusT(mAudioPolicyManager->registerPolicyMixes(mixes));
} else {
- return mAudioPolicyManager->unregisterPolicyMixes(mixes);
+ return binderStatusFromStatusT(mAudioPolicyManager->unregisterPolicyMixes(mixes));
}
}
-status_t AudioPolicyService::setUidDeviceAffinities(uid_t uid,
- const AudioDeviceTypeAddrVector& devices) {
+Status AudioPolicyService::setUidDeviceAffinities(
+ int32_t uidAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->setUidDeviceAffinities(uid, devices);
+ return binderStatusFromStatusT(mAudioPolicyManager->setUidDeviceAffinities(uid, devices));
}
-status_t AudioPolicyService::removeUidDeviceAffinities(uid_t uid) {
+Status AudioPolicyService::removeUidDeviceAffinities(int32_t uidAidl) {
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->removeUidDeviceAffinities(uid);
+ return binderStatusFromStatusT(mAudioPolicyManager->removeUidDeviceAffinities(uid));
}
-status_t AudioPolicyService::setUserIdDeviceAffinities(int userId,
- const AudioDeviceTypeAddrVector& devices) {
+Status AudioPolicyService::setUserIdDeviceAffinities(
+ int32_t userIdAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices);
+ return binderStatusFromStatusT(mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices));
}
-status_t AudioPolicyService::removeUserIdDeviceAffinities(int userId) {
+Status AudioPolicyService::removeUserIdDeviceAffinities(int32_t userIdAidl) {
+ int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
+
Mutex::Autolock _l(mLock);
if(!modifyAudioRoutingAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->removeUserIdDeviceAffinities(userId);
+ return binderStatusFromStatusT(mAudioPolicyManager->removeUserIdDeviceAffinities(userId));
}
-status_t AudioPolicyService::startAudioSource(const struct audio_port_config *source,
- const audio_attributes_t *attributes,
- audio_port_handle_t *portId)
-{
+Status AudioPolicyService::startAudioSource(const media::AudioPortConfig& sourceAidl,
+ const media::AudioAttributesInternal& attributesAidl,
+ int32_t* _aidl_return) {
+ audio_port_config source = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioPortConfig_audio_port_config(sourceAidl));
+ audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
+ audio_port_handle_t portId;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioPortConfig(source)));
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ AudioValidator::validateAudioAttributes(attributes, "68953950")));
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
- status_t result = validateUsage(attributes->usage);
- if (result != NO_ERROR) {
- return result;
- }
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
// startAudioSource should be created as the calling uid
const uid_t callingUid = IPCThreadState::self()->getCallingUid();
AutoCallerClear acc;
- return mAudioPolicyManager->startAudioSource(source, attributes, portId, callingUid);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->startAudioSource(&source, &attributes, &portId, callingUid)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
+ return Status::ok();
}
-status_t AudioPolicyService::stopAudioSource(audio_port_handle_t portId)
+Status AudioPolicyService::stopAudioSource(int32_t portIdAidl)
{
+ audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
+
Mutex::Autolock _l(mLock);
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
AutoCallerClear acc;
- return mAudioPolicyManager->stopAudioSource(portId);
+ return binderStatusFromStatusT(mAudioPolicyManager->stopAudioSource(portId));
}
-status_t AudioPolicyService::setMasterMono(bool mono)
+Status AudioPolicyService::setMasterMono(bool mono)
{
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
if (!settingsAllowed()) {
- return PERMISSION_DENIED;
+ return binderStatusFromStatusT(PERMISSION_DENIED);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setMasterMono(mono);
+ return binderStatusFromStatusT(mAudioPolicyManager->setMasterMono(mono));
}
-status_t AudioPolicyService::getMasterMono(bool *mono)
+Status AudioPolicyService::getMasterMono(bool* _aidl_return)
{
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getMasterMono(mono);
+ return binderStatusFromStatusT(mAudioPolicyManager->getMasterMono(_aidl_return));
}
-float AudioPolicyService::getStreamVolumeDB(
- audio_stream_type_t stream, int index, audio_devices_t device)
-{
+Status AudioPolicyService::getStreamVolumeDB(media::AudioStreamType streamAidl, int32_t indexAidl,
+ int32_t deviceAidl, float* _aidl_return) {
+ audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
+ int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
+ audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_audio_devices_t(deviceAidl));
+
if (mAudioPolicyManager == NULL) {
- return NAN;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
+ *_aidl_return = mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
+ return Status::ok();
}
-status_t AudioPolicyService::getSurroundFormats(unsigned int *numSurroundFormats,
- audio_format_t *surroundFormats,
- bool *surroundFormatsEnabled,
- bool reported)
-{
+Status AudioPolicyService::getSurroundFormats(
+ bool reported, media::Int* count,
+ std::vector<media::audio::common::AudioFormat>* formats,
+ bool* _aidl_return) {
+ unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
+ convertIntegral<unsigned int>(count->value));
+ if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
+ numSurroundFormats = MAX_ITEMS_PER_LIST;
+ }
+ unsigned int numSurroundFormatsReq = numSurroundFormats;
+ std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getSurroundFormats(numSurroundFormats, surroundFormats,
- surroundFormatsEnabled, reported);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getSurroundFormats(&numSurroundFormats, surroundFormats.get(),
+ _aidl_return, reported)));
+ numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
+ std::back_inserter(*formats), legacy2aidl_audio_format_t_AudioFormat)));
+ count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
+ return Status::ok();
}
-status_t AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
- std::vector<audio_format_t> *formats)
-{
+Status AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
+ std::vector<media::audio::common::AudioFormat>* _aidl_return) {
+ std::vector<audio_format_t> formats;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(formats);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(&formats)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::audio::common::AudioFormat>>(
+ formats,
+ legacy2aidl_audio_format_t_AudioFormat));
+ return Status::ok();
}
-status_t AudioPolicyService::setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled)
-{
+Status AudioPolicyService::setSurroundFormatEnabled(
+ media::audio::common::AudioFormat audioFormatAidl, bool enabled) {
+ audio_format_t audioFormat = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioFormat_audio_format_t(audioFormatAidl));
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));
}
-status_t AudioPolicyService::setAssistantUid(uid_t uid)
+Status AudioPolicyService::setAssistantUid(int32_t uidAidl)
{
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
Mutex::Autolock _l(mLock);
mUidPolicy->setAssistantUid(uid);
- return NO_ERROR;
+ return Status::ok();
}
-status_t AudioPolicyService::setA11yServicesUids(const std::vector<uid_t>& uids)
+Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)
{
+ size_t size = uidsAidl.size();
+ if (size > MAX_ITEMS_PER_LIST) {
+ size = MAX_ITEMS_PER_LIST;
+ }
+ std::vector<uid_t> uids;
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ convertRange(uidsAidl.begin(),
+ uidsAidl.begin() + size,
+ std::back_inserter(uids),
+ aidl2legacy_int32_t_uid_t)));
Mutex::Autolock _l(mLock);
mUidPolicy->setA11yUids(uids);
- return NO_ERROR;
+ return Status::ok();
}
-status_t AudioPolicyService::setCurrentImeUid(uid_t uid)
+Status AudioPolicyService::setCurrentImeUid(int32_t uidAidl)
{
+ uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
Mutex::Autolock _l(mLock);
mUidPolicy->setCurrentImeUid(uid);
- return NO_ERROR;
+ return Status::ok();
}
-bool AudioPolicyService::isHapticPlaybackSupported()
+Status AudioPolicyService::isHapticPlaybackSupported(bool* _aidl_return)
{
if (mAudioPolicyManager == NULL) {
- ALOGW("%s, mAudioPolicyManager == NULL", __func__);
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->isHapticPlaybackSupported();
+ *_aidl_return = mAudioPolicyManager->isHapticPlaybackSupported();
+ return Status::ok();
}
-status_t AudioPolicyService::listAudioProductStrategies(AudioProductStrategyVector &strategies)
-{
+Status AudioPolicyService::listAudioProductStrategies(
+ std::vector<media::AudioProductStrategy>* _aidl_return) {
+ AudioProductStrategyVector strategies;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->listAudioProductStrategies(strategies);
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(mAudioPolicyManager->listAudioProductStrategies(strategies)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::AudioProductStrategy>>(
+ strategies,
+ legacy2aidl_AudioProductStrategy));
+ return Status::ok();
}
-status_t AudioPolicyService::getProductStrategyFromAudioAttributes(
- const AudioAttributes &aa, product_strategy_t &productStrategy)
-{
+Status AudioPolicyService::getProductStrategyFromAudioAttributes(
+ const media::AudioAttributesEx& aaAidl, int32_t* _aidl_return) {
+ AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
+ product_strategy_t productStrategy;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa, productStrategy);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getProductStrategyFromAudioAttributes(aa,
+ productStrategy)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ legacy2aidl_product_strategy_t_int32_t(productStrategy));
+ return Status::ok();
}
-status_t AudioPolicyService::listAudioVolumeGroups(AudioVolumeGroupVector &groups)
+Status AudioPolicyService::listAudioVolumeGroups(std::vector<media::AudioVolumeGroup>* _aidl_return)
{
+ AudioVolumeGroupVector groups;
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->listAudioVolumeGroups(groups);
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(mAudioPolicyManager->listAudioVolumeGroups(groups)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::AudioVolumeGroup>>(groups,
+ legacy2aidl_AudioVolumeGroup));
+ return Status::ok();
}
-status_t AudioPolicyService::getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
- volume_group_t &volumeGroup)
-{
+Status AudioPolicyService::getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx& aaAidl,
+ int32_t* _aidl_return) {
+ AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
+ volume_group_t volumeGroup;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup);
+ RETURN_IF_BINDER_ERROR(
+ binderStatusFromStatusT(
+ mAudioPolicyManager->getVolumeGroupFromAudioAttributes(aa, volumeGroup)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_volume_group_t_int32_t(volumeGroup));
+ return Status::ok();
}
-status_t AudioPolicyService::setRttEnabled(bool enabled)
+Status AudioPolicyService::setRttEnabled(bool enabled)
{
Mutex::Autolock _l(mLock);
mUidPolicy->setRttEnabled(enabled);
- return NO_ERROR;
+ return Status::ok();
}
-bool AudioPolicyService::isCallScreenModeSupported()
+Status AudioPolicyService::isCallScreenModeSupported(bool* _aidl_return)
{
if (mAudioPolicyManager == NULL) {
- ALOGW("%s, mAudioPolicyManager == NULL", __func__);
- return false;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
AutoCallerClear acc;
- return mAudioPolicyManager->isCallScreenModeSupported();
+ *_aidl_return = mAudioPolicyManager->isCallScreenModeSupported();
+ return Status::ok();
}
-status_t AudioPolicyService::setDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::setDevicesRoleForStrategy(
+ int32_t strategyAidl,
+ media::DeviceRole roleAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices));
}
-status_t AudioPolicyService::removeDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role)
-{
+Status AudioPolicyService::removeDevicesRoleForStrategy(int32_t strategyAidl,
+ media::DeviceRole roleAidl) {
+ product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ if (mAudioPolicyManager == NULL) {
+ return binderStatusFromStatusT(NO_INIT);
+ }
+ Mutex::Autolock _l(mLock);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role));
+}
+
+Status AudioPolicyService::getDevicesForRoleAndStrategy(
+ int32_t strategyAidl,
+ media::DeviceRole roleAidl,
+ std::vector<media::AudioDevice>* _aidl_return) {
+ product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_int32_t_product_strategy_t(strategyAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices;
+
if (mAudioPolicyManager == NULL) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return Status::ok();
}
-status_t AudioPolicyService::getDevicesForRoleAndStrategy(product_strategy_t strategy,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices)
-{
- if (mAudioPolicyManager == NULL) {
- return NO_INIT;
- }
- Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices);
+Status AudioPolicyService::registerSoundTriggerCaptureStateListener(
+ const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) {
+ *_aidl_return = mCaptureStateNotifier.RegisterListener(listener);
+ return Status::ok();
}
-status_t AudioPolicyService::registerSoundTriggerCaptureStateListener(
- const sp<media::ICaptureStateListener>& listener,
- bool* result)
-{
- *result = mCaptureStateNotifier.RegisterListener(listener);
- return NO_ERROR;
-}
+Status AudioPolicyService::setDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSourceAidl,
+ media::DeviceRole roleAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
-status_t AudioPolicyService::setDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices)
-{
if (mAudioPolicyManager == nullptr) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices));
}
-status_t AudioPolicyService::addDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::addDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSourceAidl,
+ media::DeviceRole roleAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+
if (mAudioPolicyManager == nullptr) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices));
}
-status_t AudioPolicyService::removeDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role, const AudioDeviceTypeAddrVector& devices)
-{
- if (mAudioPolicyManager == nullptr) {
- return NO_INIT;
+Status AudioPolicyService::removeDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSourceAidl,
+ media::DeviceRole roleAidl,
+ const std::vector<media::AudioDevice>& devicesAidl) {
+ audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
+ aidl2legacy_AudioDeviceTypeAddress));
+
+ if (mAudioPolicyManager == nullptr) {
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
}
-status_t AudioPolicyService::clearDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role)
-{
+Status AudioPolicyService::clearDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,
+ media::DeviceRole roleAidl) {
+ audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+
if (mAudioPolicyManager == nullptr) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role);
+ return binderStatusFromStatusT(
+ mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role));
}
-status_t AudioPolicyService::getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices)
-{
+Status AudioPolicyService::getDevicesForRoleAndCapturePreset(
+ media::AudioSourceType audioSourceAidl,
+ media::DeviceRole roleAidl,
+ std::vector<media::AudioDevice>* _aidl_return) {
+ audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
+ device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
+ aidl2legacy_DeviceRole_device_role_t(roleAidl));
+ AudioDeviceTypeAddrVector devices;
+
if (mAudioPolicyManager == nullptr) {
- return NO_INIT;
+ return binderStatusFromStatusT(NO_INIT);
}
Mutex::Autolock _l(mLock);
- return mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices);
+ RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
+ mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices)));
+ *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
+ convertContainer<std::vector<media::AudioDevice>>(devices,
+ legacy2aidl_AudioDeviceTypeAddress));
+ return Status::ok();
}
} // namespace android
diff --git a/services/audiopolicy/service/AudioPolicyService.cpp b/services/audiopolicy/service/AudioPolicyService.cpp
index 80022c8..4ce6dc1 100644
--- a/services/audiopolicy/service/AudioPolicyService.cpp
+++ b/services/audiopolicy/service/AudioPolicyService.cpp
@@ -39,12 +39,14 @@
#include <media/AudioEffect.h>
#include <media/AudioParameter.h>
#include <mediautils/ServiceUtilities.h>
+#include <mediautils/TimeCheck.h>
#include <sensorprivacy/SensorPrivacyManager.h>
#include <system/audio.h>
#include <system/audio_policy.h>
namespace android {
+using binder::Status;
static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
@@ -112,11 +114,11 @@
// A notification client is always registered by AudioSystem when the client process
// connects to AudioPolicyService.
-void AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
+Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
{
if (client == 0) {
ALOGW("%s got NULL client", __FUNCTION__);
- return;
+ return Status::ok();
}
Mutex::Autolock _l(mNotificationClientsLock);
@@ -136,9 +138,10 @@
sp<IBinder> binder = IInterface::asBinder(client);
binder->linkToDeath(notificationClient);
}
+ return Status::ok();
}
-void AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
+Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
{
Mutex::Autolock _l(mNotificationClientsLock);
@@ -147,12 +150,13 @@
int64_t token = ((int64_t)uid<<32) | pid;
if (mNotificationClients.indexOfKey(token) < 0) {
- return;
+ return Status::ok();
}
mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
+ return Status::ok();
}
-void AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
+Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
{
Mutex::Autolock _l(mNotificationClientsLock);
@@ -161,9 +165,10 @@
int64_t token = ((int64_t)uid<<32) | pid;
if (mNotificationClients.indexOfKey(token) < 0) {
- return;
+ return Status::ok();
}
mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
+ return Status::ok();
}
// removeNotificationClient() is called when the client process dies.
@@ -816,6 +821,92 @@
status_t AudioPolicyService::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
+ // make sure transactions reserved to AudioFlinger do not come from other processes
+ switch (code) {
+ case TRANSACTION_startOutput:
+ case TRANSACTION_stopOutput:
+ case TRANSACTION_releaseOutput:
+ case TRANSACTION_getInputForAttr:
+ case TRANSACTION_startInput:
+ case TRANSACTION_stopInput:
+ case TRANSACTION_releaseInput:
+ case TRANSACTION_getOutputForEffect:
+ case TRANSACTION_registerEffect:
+ case TRANSACTION_unregisterEffect:
+ case TRANSACTION_setEffectEnabled:
+ case TRANSACTION_getStrategyForStream:
+ case TRANSACTION_getOutputForAttr:
+ case TRANSACTION_moveEffectsToIo:
+ ALOGW("%s: transaction %d received from PID %d",
+ __func__, code, IPCThreadState::self()->getCallingPid());
+ return INVALID_OPERATION;
+ default:
+ break;
+ }
+
+ // make sure the following transactions come from system components
+ switch (code) {
+ case TRANSACTION_setDeviceConnectionState:
+ case TRANSACTION_handleDeviceConfigChange:
+ case TRANSACTION_setPhoneState:
+//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
+// case TRANSACTION_setForceUse:
+ case TRANSACTION_initStreamVolume:
+ case TRANSACTION_setStreamVolumeIndex:
+ case TRANSACTION_setVolumeIndexForAttributes:
+ case TRANSACTION_getStreamVolumeIndex:
+ case TRANSACTION_getVolumeIndexForAttributes:
+ case TRANSACTION_getMinVolumeIndexForAttributes:
+ case TRANSACTION_getMaxVolumeIndexForAttributes:
+ case TRANSACTION_isStreamActive:
+ case TRANSACTION_isStreamActiveRemotely:
+ case TRANSACTION_isSourceActive:
+ case TRANSACTION_getDevicesForStream:
+ case TRANSACTION_registerPolicyMixes:
+ case TRANSACTION_setMasterMono:
+ case TRANSACTION_getSurroundFormats:
+ case TRANSACTION_setSurroundFormatEnabled:
+ case TRANSACTION_setAssistantUid:
+ case TRANSACTION_setA11yServicesUids:
+ case TRANSACTION_setUidDeviceAffinities:
+ case TRANSACTION_removeUidDeviceAffinities:
+ case TRANSACTION_setUserIdDeviceAffinities:
+ case TRANSACTION_removeUserIdDeviceAffinities:
+ case TRANSACTION_getHwOffloadEncodingFormatsSupportedForA2DP:
+ case TRANSACTION_listAudioVolumeGroups:
+ case TRANSACTION_getVolumeGroupFromAudioAttributes:
+ case TRANSACTION_acquireSoundTriggerSession:
+ case TRANSACTION_releaseSoundTriggerSession:
+ case TRANSACTION_setRttEnabled:
+ case TRANSACTION_isCallScreenModeSupported:
+ case TRANSACTION_setDevicesRoleForStrategy:
+ case TRANSACTION_setSupportedSystemUsages:
+ case TRANSACTION_removeDevicesRoleForStrategy:
+ case TRANSACTION_getDevicesForRoleAndStrategy:
+ case TRANSACTION_getDevicesForAttributes:
+ case TRANSACTION_setAllowedCapturePolicy:
+ case TRANSACTION_onNewAudioModulesAvailable:
+ case TRANSACTION_setCurrentImeUid:
+ case TRANSACTION_registerSoundTriggerCaptureStateListener:
+ case TRANSACTION_setDevicesRoleForCapturePreset:
+ case TRANSACTION_addDevicesRoleForCapturePreset:
+ case TRANSACTION_removeDevicesRoleForCapturePreset:
+ case TRANSACTION_clearDevicesRoleForCapturePreset:
+ case TRANSACTION_getDevicesForRoleAndCapturePreset: {
+ if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
+ ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
+ __func__, code, IPCThreadState::self()->getCallingPid(),
+ IPCThreadState::self()->getCallingUid());
+ return INVALID_OPERATION;
+ }
+ } break;
+ default:
+ break;
+ }
+
+ std::string tag("IAudioPolicyService command " + std::to_string(code));
+ TimeCheck check(tag.c_str());
+
switch (code) {
case SHELL_COMMAND_TRANSACTION: {
int in = data.readFileDescriptor();
@@ -2022,9 +2113,10 @@
mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
}
-void AudioPolicyService::onNewAudioModulesAvailable()
+Status AudioPolicyService::onNewAudioModulesAvailable()
{
mOutputCommandThread->audioModulesUpdateCommand();
+ return Status::ok();
}
diff --git a/services/audiopolicy/service/AudioPolicyService.h b/services/audiopolicy/service/AudioPolicyService.h
index 2cb8759..c22ed9b 100644
--- a/services/audiopolicy/service/AudioPolicyService.h
+++ b/services/audiopolicy/service/AudioPolicyService.h
@@ -17,6 +17,7 @@
#ifndef ANDROID_AUDIOPOLICYSERVICE_H
#define ANDROID_AUDIOPOLICYSERVICE_H
+#include <android/media/BnAudioPolicyService.h>
#include <android-base/thread_annotations.h>
#include <cutils/misc.h>
#include <cutils/config_utils.h>
@@ -29,7 +30,6 @@
#include <binder/IUidObserver.h>
#include <system/audio.h>
#include <system/audio_policy.h>
-#include <media/IAudioPolicyService.h>
#include <media/ToneGenerator.h>
#include <media/AudioEffect.h>
#include <media/AudioPolicy.h>
@@ -47,7 +47,7 @@
class AudioPolicyService :
public BinderService<AudioPolicyService>,
- public BnAudioPolicyService,
+ public media::BnAudioPolicyService,
public IBinder::DeathRecipient
{
friend class BinderService<AudioPolicyService>;
@@ -61,108 +61,175 @@
//
// BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
//
-
- void onNewAudioModulesAvailable() override;
- virtual status_t setDeviceConnectionState(audio_devices_t device,
- audio_policy_dev_state_t state,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat);
- virtual audio_policy_dev_state_t getDeviceConnectionState(
- audio_devices_t device,
- const char *device_address);
- virtual status_t handleDeviceConfigChange(audio_devices_t device,
- const char *device_address,
- const char *device_name,
- audio_format_t encodedFormat);
- virtual status_t setPhoneState(audio_mode_t state, uid_t uid);
- virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
- virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
- virtual audio_io_handle_t getOutput(audio_stream_type_t stream);
- status_t getOutputForAttr(audio_attributes_t *attr,
- audio_io_handle_t *output,
- audio_session_t session,
- audio_stream_type_t *stream,
- pid_t pid,
- uid_t uid,
- const audio_config_t *config,
- audio_output_flags_t flags,
- audio_port_handle_t *selectedDeviceId,
- audio_port_handle_t *portId,
- std::vector<audio_io_handle_t> *secondaryOutputs) override;
- virtual status_t startOutput(audio_port_handle_t portId);
- virtual status_t stopOutput(audio_port_handle_t portId);
- virtual void releaseOutput(audio_port_handle_t portId);
- virtual status_t getInputForAttr(const audio_attributes_t *attr,
- audio_io_handle_t *input,
- audio_unique_id_t riid,
- audio_session_t session,
- pid_t pid,
- uid_t uid,
- const String16& opPackageName,
- const audio_config_base_t *config,
- audio_input_flags_t flags,
- audio_port_handle_t *selectedDeviceId = NULL,
- audio_port_handle_t *portId = NULL);
- virtual status_t startInput(audio_port_handle_t portId);
- virtual status_t stopInput(audio_port_handle_t portId);
- virtual void releaseInput(audio_port_handle_t portId);
- virtual status_t initStreamVolume(audio_stream_type_t stream,
- int indexMin,
- int indexMax);
- virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,
- int index,
- audio_devices_t device);
- virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,
- int *index,
- audio_devices_t device);
-
- virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr,
- int index,
- audio_devices_t device);
- virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr,
- int &index,
- audio_devices_t device);
- virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr,
- int &index);
- virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr,
- int &index);
-
- virtual uint32_t getStrategyForStream(audio_stream_type_t stream);
- virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);
- virtual status_t getDevicesForAttributes(const AudioAttributes &aa,
- AudioDeviceTypeAddrVector *devices) const;
-
- virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc);
- virtual status_t registerEffect(const effect_descriptor_t *desc,
- audio_io_handle_t io,
- uint32_t strategy,
- audio_session_t session,
- int id);
- virtual status_t unregisterEffect(int id);
- virtual status_t setEffectEnabled(int id, bool enabled);
- status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) override;
- virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
- virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;
- virtual bool isSourceActive(audio_source_t source) const;
-
- virtual status_t queryDefaultPreProcessing(audio_session_t audioSession,
- effect_descriptor_t *descriptors,
- uint32_t *count);
- virtual status_t addSourceDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_source_t source,
- audio_unique_id_t* id);
- virtual status_t addStreamDefaultEffect(const effect_uuid_t *type,
- const String16& opPackageName,
- const effect_uuid_t *uuid,
- int32_t priority,
- audio_usage_t usage,
- audio_unique_id_t* id);
- virtual status_t removeSourceDefaultEffect(audio_unique_id_t id);
- virtual status_t removeStreamDefaultEffect(audio_unique_id_t id);
+ binder::Status onNewAudioModulesAvailable() override;
+ binder::Status setDeviceConnectionState(
+ const media::AudioDevice& device,
+ media::AudioPolicyDeviceState state,
+ const std::string& deviceName,
+ media::audio::common::AudioFormat encodedFormat) override;
+ binder::Status getDeviceConnectionState(const media::AudioDevice& device,
+ media::AudioPolicyDeviceState* _aidl_return) override;
+ binder::Status handleDeviceConfigChange(
+ const media::AudioDevice& device,
+ const std::string& deviceName,
+ media::audio::common::AudioFormat encodedFormat) override;
+ binder::Status setPhoneState(media::AudioMode state, int32_t uid) override;
+ binder::Status setForceUse(media::AudioPolicyForceUse usage,
+ media::AudioPolicyForcedConfig config) override;
+ binder::Status getForceUse(media::AudioPolicyForceUse usage,
+ media::AudioPolicyForcedConfig* _aidl_return) override;
+ binder::Status getOutput(media::AudioStreamType stream, int32_t* _aidl_return) override;
+ binder::Status getOutputForAttr(const media::AudioAttributesInternal& attr, int32_t session,
+ int32_t pid, int32_t uid, const media::AudioConfig& config,
+ int32_t flags,
+ media::GetOutputForAttrResponse* _aidl_return) override;
+ binder::Status startOutput(int32_t portId) override;
+ binder::Status stopOutput(int32_t portId) override;
+ binder::Status releaseOutput(int32_t portId) override;
+ binder::Status getInputForAttr(const media::AudioAttributesInternal& attr, int32_t input,
+ int32_t riid, int32_t session, int32_t pid, int32_t uid,
+ const std::string& opPackageName,
+ const media::AudioConfigBase& config, int32_t flags,
+ media::GetInputForAttrResponse* _aidl_return) override;
+ binder::Status startInput(int32_t portId) override;
+ binder::Status stopInput(int32_t portId) override;
+ binder::Status releaseInput(int32_t portId) override;
+ binder::Status initStreamVolume(media::AudioStreamType stream, int32_t indexMin,
+ int32_t indexMax) override;
+ binder::Status setStreamVolumeIndex(media::AudioStreamType stream, int32_t device,
+ int32_t index) override;
+ binder::Status getStreamVolumeIndex(media::AudioStreamType stream, int32_t device,
+ int32_t* _aidl_return) override;
+ binder::Status setVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+ int32_t device, int32_t index) override;
+ binder::Status getVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+ int32_t device, int32_t* _aidl_return) override;
+ binder::Status getMaxVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+ int32_t* _aidl_return) override;
+ binder::Status getMinVolumeIndexForAttributes(const media::AudioAttributesInternal& attr,
+ int32_t* _aidl_return) override;
+ binder::Status getStrategyForStream(media::AudioStreamType stream,
+ int32_t* _aidl_return) override;
+ binder::Status getDevicesForStream(media::AudioStreamType stream,
+ int32_t* _aidl_return) override;
+ binder::Status getDevicesForAttributes(const media::AudioAttributesEx& attr,
+ std::vector<media::AudioDevice>* _aidl_return) override;
+ binder::Status getOutputForEffect(const media::EffectDescriptor& desc,
+ int32_t* _aidl_return) override;
+ binder::Status registerEffect(const media::EffectDescriptor& desc, int32_t io, int32_t strategy,
+ int32_t session, int32_t id) override;
+ binder::Status unregisterEffect(int32_t id) override;
+ binder::Status setEffectEnabled(int32_t id, bool enabled) override;
+ binder::Status moveEffectsToIo(const std::vector<int32_t>& ids, int32_t io) override;
+ binder::Status isStreamActive(media::AudioStreamType stream, int32_t inPastMs,
+ bool* _aidl_return) override;
+ binder::Status isStreamActiveRemotely(media::AudioStreamType stream, int32_t inPastMs,
+ bool* _aidl_return) override;
+ binder::Status isSourceActive(media::AudioSourceType source, bool* _aidl_return) override;
+ binder::Status queryDefaultPreProcessing(
+ int32_t audioSession, media::Int* count,
+ std::vector<media::EffectDescriptor>* _aidl_return) override;
+ binder::Status addSourceDefaultEffect(const media::AudioUuid& type,
+ const std::string& opPackageName,
+ const media::AudioUuid& uuid, int32_t priority,
+ media::AudioSourceType source,
+ int32_t* _aidl_return) override;
+ binder::Status addStreamDefaultEffect(const media::AudioUuid& type,
+ const std::string& opPackageName,
+ const media::AudioUuid& uuid, int32_t priority,
+ media::AudioUsage usage, int32_t* _aidl_return) override;
+ binder::Status removeSourceDefaultEffect(int32_t id) override;
+ binder::Status removeStreamDefaultEffect(int32_t id) override;
+ binder::Status setSupportedSystemUsages(
+ const std::vector<media::AudioUsage>& systemUsages) override;
+ binder::Status setAllowedCapturePolicy(int32_t uid, int32_t capturePolicy) override;
+ binder::Status getOffloadSupport(const media::AudioOffloadInfo& info,
+ media::AudioOffloadMode* _aidl_return) override;
+ binder::Status isDirectOutputSupported(const media::AudioConfigBase& config,
+ const media::AudioAttributesInternal& attributes,
+ bool* _aidl_return) override;
+ binder::Status listAudioPorts(media::AudioPortRole role, media::AudioPortType type,
+ media::Int* count, std::vector<media::AudioPort>* ports,
+ int32_t* _aidl_return) override;
+ binder::Status getAudioPort(const media::AudioPort& port,
+ media::AudioPort* _aidl_return) override;
+ binder::Status createAudioPatch(const media::AudioPatch& patch, int32_t handle,
+ int32_t* _aidl_return) override;
+ binder::Status releaseAudioPatch(int32_t handle) override;
+ binder::Status listAudioPatches(media::Int* count, std::vector<media::AudioPatch>* patches,
+ int32_t* _aidl_return) override;
+ binder::Status setAudioPortConfig(const media::AudioPortConfig& config) override;
+ binder::Status registerClient(const sp<media::IAudioPolicyServiceClient>& client) override;
+ binder::Status setAudioPortCallbacksEnabled(bool enabled) override;
+ binder::Status setAudioVolumeGroupCallbacksEnabled(bool enabled) override;
+ binder::Status acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return) override;
+ binder::Status releaseSoundTriggerSession(int32_t session) override;
+ binder::Status getPhoneState(media::AudioMode* _aidl_return) override;
+ binder::Status registerPolicyMixes(const std::vector<media::AudioMix>& mixes,
+ bool registration) override;
+ binder::Status setUidDeviceAffinities(int32_t uid,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status removeUidDeviceAffinities(int32_t uid) override;
+ binder::Status setUserIdDeviceAffinities(
+ int32_t userId,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status removeUserIdDeviceAffinities(int32_t userId) override;
+ binder::Status startAudioSource(const media::AudioPortConfig& source,
+ const media::AudioAttributesInternal& attributes,
+ int32_t* _aidl_return) override;
+ binder::Status stopAudioSource(int32_t portId) override;
+ binder::Status setMasterMono(bool mono) override;
+ binder::Status getMasterMono(bool* _aidl_return) override;
+ binder::Status getStreamVolumeDB(media::AudioStreamType stream, int32_t index, int32_t device,
+ float* _aidl_return) override;
+ binder::Status getSurroundFormats(bool reported, media::Int* count,
+ std::vector<media::audio::common::AudioFormat>* formats,
+ bool* _aidl_return) override;
+ binder::Status getHwOffloadEncodingFormatsSupportedForA2DP(
+ std::vector<media::audio::common::AudioFormat>* _aidl_return) override;
+ binder::Status setSurroundFormatEnabled(media::audio::common::AudioFormat audioFormat,
+ bool enabled) override;
+ binder::Status setAssistantUid(int32_t uid) override;
+ binder::Status setA11yServicesUids(const std::vector<int32_t>& uids) override;
+ binder::Status setCurrentImeUid(int32_t uid) override;
+ binder::Status isHapticPlaybackSupported(bool* _aidl_return) override;
+ binder::Status listAudioProductStrategies(
+ std::vector<media::AudioProductStrategy>* _aidl_return) override;
+ binder::Status getProductStrategyFromAudioAttributes(const media::AudioAttributesEx& aa,
+ int32_t* _aidl_return) override;
+ binder::Status listAudioVolumeGroups(
+ std::vector<media::AudioVolumeGroup>* _aidl_return) override;
+ binder::Status getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx& aa,
+ int32_t* _aidl_return) override;
+ binder::Status setRttEnabled(bool enabled) override;
+ binder::Status isCallScreenModeSupported(bool* _aidl_return) override;
+ binder::Status setDevicesRoleForStrategy(
+ int32_t strategy, media::DeviceRole role,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status removeDevicesRoleForStrategy(int32_t strategy, media::DeviceRole role) override;
+ binder::Status getDevicesForRoleAndStrategy(
+ int32_t strategy, media::DeviceRole role,
+ std::vector<media::AudioDevice>* _aidl_return) override;
+ binder::Status setDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSource,
+ media::DeviceRole role,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status addDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSource,
+ media::DeviceRole role,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status removeDevicesRoleForCapturePreset(
+ media::AudioSourceType audioSource,
+ media::DeviceRole role,
+ const std::vector<media::AudioDevice>& devices) override;
+ binder::Status clearDevicesRoleForCapturePreset(media::AudioSourceType audioSource,
+ media::DeviceRole role) override;
+ binder::Status getDevicesForRoleAndCapturePreset(
+ media::AudioSourceType audioSource,
+ media::DeviceRole role,
+ std::vector<media::AudioDevice>* _aidl_return) override;
+ binder::Status registerSoundTriggerCaptureStateListener(
+ const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) override;
virtual status_t onTransact(
uint32_t code,
@@ -190,170 +257,53 @@
audio_io_handle_t output,
int delayMs = 0);
virtual status_t setVoiceVolume(float volume, int delayMs = 0);
- status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages);
- status_t setAllowedCapturePolicy(uint_t uid, audio_flags_mask_t capturePolicy) override;
- virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t &config);
- virtual bool isDirectOutputSupported(const audio_config_base_t& config,
- const audio_attributes_t& attributes);
- virtual status_t listAudioPorts(audio_port_role_t role,
- audio_port_type_t type,
- unsigned int *num_ports,
- struct audio_port_v7 *ports,
- unsigned int *generation);
- virtual status_t getAudioPort(struct audio_port_v7 *port);
- virtual status_t createAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle);
- virtual status_t releaseAudioPatch(audio_patch_handle_t handle);
- virtual status_t listAudioPatches(unsigned int *num_patches,
- struct audio_patch *patches,
- unsigned int *generation);
- virtual status_t setAudioPortConfig(const struct audio_port_config *config);
+ void doOnNewAudioModulesAvailable();
+ status_t doStopOutput(audio_port_handle_t portId);
+ void doReleaseOutput(audio_port_handle_t portId);
- virtual void registerClient(const sp<media::IAudioPolicyServiceClient>& client);
+ status_t clientCreateAudioPatch(const struct audio_patch *patch,
+ audio_patch_handle_t *handle,
+ int delayMs);
+ status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
+ int delayMs);
+ virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
+ int delayMs);
- virtual void setAudioPortCallbacksEnabled(bool enabled);
+ void removeNotificationClient(uid_t uid, pid_t pid);
+ void onAudioPortListUpdate();
+ void doOnAudioPortListUpdate();
+ void onAudioPatchListUpdate();
+ void doOnAudioPatchListUpdate();
- virtual void setAudioVolumeGroupCallbacksEnabled(bool enabled);
+ void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
+ void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
+ 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);
+ void doOnRecordingConfigurationUpdate(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);
- virtual status_t acquireSoundTriggerSession(audio_session_t *session,
- audio_io_handle_t *ioHandle,
- audio_devices_t *device);
+ void onAudioVolumeGroupChanged(volume_group_t group, int flags);
+ void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
- virtual status_t releaseSoundTriggerSession(audio_session_t session);
+ void onRoutingUpdated();
+ void doOnRoutingUpdated();
- virtual audio_mode_t getPhoneState();
-
- virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration);
-
- virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices);
-
- virtual status_t removeUidDeviceAffinities(uid_t uid);
-
- virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices);
-
- virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role);
-
- virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices);
-
- virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices);
-
- virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role,
- const AudioDeviceTypeAddrVector &devices);
-
- virtual status_t removeDevicesRoleForCapturePreset(
- audio_source_t audioSource, device_role_t role,
- const AudioDeviceTypeAddrVector& devices);
-
- virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource,
- device_role_t role);
-
- virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource,
- device_role_t role,
- AudioDeviceTypeAddrVector &devices);
-
- virtual status_t setUserIdDeviceAffinities(int userId,
- const AudioDeviceTypeAddrVector& devices);
-
- virtual status_t removeUserIdDeviceAffinities(int userId);
-
- virtual status_t startAudioSource(const struct audio_port_config *source,
- const audio_attributes_t *attributes,
- audio_port_handle_t *portId);
- virtual status_t stopAudioSource(audio_port_handle_t portId);
-
- virtual status_t setMasterMono(bool mono);
- virtual status_t getMasterMono(bool *mono);
-
- virtual float getStreamVolumeDB(
- audio_stream_type_t stream, int index, audio_devices_t device);
-
- virtual status_t getSurroundFormats(unsigned int *numSurroundFormats,
- audio_format_t *surroundFormats,
- bool *surroundFormatsEnabled,
- bool reported);
- virtual status_t getHwOffloadEncodingFormatsSupportedForA2DP(
- std::vector<audio_format_t> *formats);
- virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled);
-
- virtual status_t setAssistantUid(uid_t uid);
- virtual status_t setA11yServicesUids(const std::vector<uid_t>& uids);
- virtual status_t setCurrentImeUid(uid_t uid);
-
- virtual bool isHapticPlaybackSupported();
-
- virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies);
- virtual status_t getProductStrategyFromAudioAttributes(const AudioAttributes &aa,
- product_strategy_t &productStrategy);
-
- virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups);
-
- virtual status_t getVolumeGroupFromAudioAttributes(const AudioAttributes &aa,
- volume_group_t &volumeGroup);
-
- status_t registerSoundTriggerCaptureStateListener(
- const sp<media::ICaptureStateListener>& listener,
- bool* result) override;
-
- virtual status_t setRttEnabled(bool enabled);
-
- virtual bool isUserSensorPrivacyEnabledForUid(uid_t uid);
-
- bool isCallScreenModeSupported() override;
-
- void doOnNewAudioModulesAvailable();
- status_t doStopOutput(audio_port_handle_t portId);
- void doReleaseOutput(audio_port_handle_t portId);
-
- status_t clientCreateAudioPatch(const struct audio_patch *patch,
- audio_patch_handle_t *handle,
- int delayMs);
- status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
- int delayMs);
- virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
- int delayMs);
-
- void removeNotificationClient(uid_t uid, pid_t pid);
- void onAudioPortListUpdate();
- void doOnAudioPortListUpdate();
- void onAudioPatchListUpdate();
- void doOnAudioPatchListUpdate();
-
- void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
- void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
- 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);
- void doOnRecordingConfigurationUpdate(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);
-
- void onAudioVolumeGroupChanged(volume_group_t group, int flags);
- void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
-
- void onRoutingUpdated();
- void doOnRoutingUpdated();
-
- void setEffectSuspended(int effectId,
- audio_session_t sessionId,
- bool suspended);
+ void setEffectSuspended(int effectId,
+ audio_session_t sessionId,
+ bool suspended);
private:
AudioPolicyService() ANDROID_API;
@@ -389,6 +339,8 @@
status_t validateUsage(audio_usage_t usage);
status_t validateUsage(audio_usage_t usage, pid_t pid, uid_t uid);
+ bool isUserSensorPrivacyEnabledForUid(uid_t uid);
+
void updateUidStates();
void updateUidStates_l() REQUIRES(mLock);