Convert IAudioPolicyService to AIDL
Test: Audio tests from CtsMediaTests
Test: Audio smoke tests
Bug: 160253486
Change-Id: I5ecee56f71a959d2fd75714ba95d7653af0c98bc
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);