blob: 4ef7e9d8f1c79081319eb3d9786fae68b927e62f [file] [log] [blame]
Eric Laurent2d388ec2014-03-07 13:25:54 -08001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Atneya Nair9f91a5e2024-05-09 16:25:05 -070017#define LOG_TAG "AudioPolicyInterfaceImpl"
Eric Laurent2d388ec2014-03-07 13:25:54 -080018//#define LOG_NDEBUG 0
19
Eric Laurent2d388ec2014-03-07 13:25:54 -080020#include "AudioPolicyService.h"
Atneya Nair5b1ed642023-06-23 14:43:37 -070021#include "AudioRecordClient.h"
Ray Essick84e84a52018-05-03 18:45:07 -070022#include "TypeConverter.h"
Atneya Nair9f91a5e2024-05-09 16:25:05 -070023
24#include <android/content/AttributionSourceState.h>
Marvin Ramine5a122d2023-12-07 13:57:59 +010025#include <android_media_audiopolicy.h>
Eric Laurentdbb80322024-11-18 16:09:51 -080026#include <android_media_audio.h>
Atneya Nair89ff0432024-11-19 12:47:28 -080027#include <binder/Enums.h>
Atneya Nair09859fe2024-07-15 16:38:02 -070028#include <com_android_media_audio.h>
Eric Laurent528181a2024-10-30 18:32:15 +000029#include <cutils/properties.h>
Atneya Nair09859fe2024-07-15 16:38:02 -070030#include <error/expected_utils.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080031#include <media/AidlConversion.h>
Kevin Rocardbe201852019-02-20 22:33:28 -080032#include <media/AudioPolicy.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080033#include <media/AudioValidator.h>
34#include <media/MediaMetricsItem.h>
35#include <media/PolicyAidlConversion.h>
Eric Laurentd7fe0862018-07-14 16:48:01 -070036#include <utils/Log.h>
Eric Laurent2d388ec2014-03-07 13:25:54 -080037
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080038#define VALUE_OR_RETURN_BINDER_STATUS(x) \
39 ({ auto _tmp = (x); \
40 if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
41 std::move(_tmp.value()); })
42
Mikhail Naganov932cb962021-09-16 01:05:27 +000043#define RETURN_BINDER_STATUS_IF_ERROR(x) \
44 if (status_t _tmp = (x); _tmp != OK) return aidl_utils::binderStatusFromStatusT(_tmp);
45
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080046#define RETURN_IF_BINDER_ERROR(x) \
47 { \
48 binder::Status _tmp = (x); \
49 if (!_tmp.isOk()) return _tmp; \
50 }
51
Atneya Nair09859fe2024-07-15 16:38:02 -070052#define CHECK_PERM(expr1, expr2) \
53 VALUE_OR_RETURN_STATUS(getPermissionProvider().checkPermission((expr1), (expr2)))
54
Atneya Nair89ff0432024-11-19 12:47:28 -080055#define PROPAGATE_FALSEY(val) do { if (!val.has_value() || !val.value()) return val; } while (0)
56
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080057#define MAX_ITEMS_PER_LIST 1024
58
Eric Laurent2d388ec2014-03-07 13:25:54 -080059namespace android {
Marvin Ramine5a122d2023-12-07 13:57:59 +010060namespace audiopolicy_flags = android::media::audiopolicy;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080061using binder::Status;
62using aidl_utils::binderStatusFromStatusT;
Eric Laurentdbb80322024-11-18 16:09:51 -080063using android::media::audio::concurrent_audio_record_bypass_permission;
Atneya Nair09859fe2024-07-15 16:38:02 -070064using com::android::media::audio::audioserver_permissions;
Atneya Nair9f91a5e2024-05-09 16:25:05 -070065using com::android::media::permission::NativePermissionController;
Atneya Nair89ff0432024-11-19 12:47:28 -080066using com::android::media::permission::PermissionEnum;
Atneya Nair09859fe2024-07-15 16:38:02 -070067using com::android::media::permission::PermissionEnum::ACCESS_ULTRASOUND;
68using com::android::media::permission::PermissionEnum::CALL_AUDIO_INTERCEPTION;
69using com::android::media::permission::PermissionEnum::CAPTURE_AUDIO_HOTWORD;
70using com::android::media::permission::PermissionEnum::CAPTURE_VOICE_COMMUNICATION_OUTPUT;
71using com::android::media::permission::PermissionEnum::CAPTURE_AUDIO_OUTPUT;
72using com::android::media::permission::PermissionEnum::CAPTURE_MEDIA_OUTPUT;
73using com::android::media::permission::PermissionEnum::CAPTURE_TUNER_AUDIO_INPUT;
74using com::android::media::permission::PermissionEnum::MODIFY_AUDIO_ROUTING;
75using com::android::media::permission::PermissionEnum::MODIFY_AUDIO_SETTINGS;
76using com::android::media::permission::PermissionEnum::MODIFY_DEFAULT_AUDIO_EFFECTS;
77using com::android::media::permission::PermissionEnum::MODIFY_PHONE_STATE;
78using com::android::media::permission::PermissionEnum::RECORD_AUDIO;
79using com::android::media::permission::PermissionEnum::WRITE_SECURE_SETTINGS;
Eric Laurentdbb80322024-11-18 16:09:51 -080080using com::android::media::permission::PermissionEnum::BYPASS_CONCURRENT_RECORD_AUDIO_RESTRICTION;
Svet Ganov3e5f14f2021-05-13 22:51:08 +000081using content::AttributionSourceState;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070082using media::audio::common::AudioConfig;
83using media::audio::common::AudioConfigBase;
Mikhail Naganovf4a75362021-09-16 00:02:54 +000084using media::audio::common::AudioDevice;
Mikhail Naganov932cb962021-09-16 01:05:27 +000085using media::audio::common::AudioDeviceAddress;
Mikhail Naganovf4a75362021-09-16 00:02:54 +000086using media::audio::common::AudioDeviceDescription;
Mikhail Naganov57bd06f2021-08-10 16:41:54 -070087using media::audio::common::AudioFormatDescription;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070088using media::audio::common::AudioMode;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070089using media::audio::common::AudioOffloadInfo;
François Gaffie873738c2024-08-02 17:09:21 +020090using media::audio::common::AudioPolicyForceUse;
91using media::audio::common::AudioPolicyForcedConfig;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070092using media::audio::common::AudioSource;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070093using media::audio::common::AudioStreamType;
94using media::audio::common::AudioUsage;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070095using media::audio::common::AudioUuid;
Mikhail Naganov0078ee52021-09-30 23:06:20 +000096using media::audio::common::Int;
Eric Laurent2d388ec2014-03-07 13:25:54 -080097
Marvin Ramine5a122d2023-12-07 13:57:59 +010098constexpr int kDefaultVirtualDeviceId = 0;
Atneya Nairdb6ef1e2024-09-16 20:26:30 +000099namespace {
100constexpr auto PERMISSION_HARD_DENIED = permission::PermissionChecker::PERMISSION_HARD_DENIED;
101constexpr auto PERMISSION_GRANTED = permission::PermissionChecker::PERMISSION_GRANTED;
102}
Marvin Ramine5a122d2023-12-07 13:57:59 +0100103
Hayden Gomes524159d2019-12-23 14:41:47 -0800104const std::vector<audio_usage_t>& SYSTEM_USAGES = {
105 AUDIO_USAGE_CALL_ASSISTANT,
106 AUDIO_USAGE_EMERGENCY,
107 AUDIO_USAGE_SAFETY,
108 AUDIO_USAGE_VEHICLE_STATUS,
109 AUDIO_USAGE_ANNOUNCEMENT
110};
111
112bool isSystemUsage(audio_usage_t usage) {
113 return std::find(std::begin(SYSTEM_USAGES), std::end(SYSTEM_USAGES), usage)
114 != std::end(SYSTEM_USAGES);
115}
116
117bool AudioPolicyService::isSupportedSystemUsage(audio_usage_t usage) {
118 return std::find(std::begin(mSupportedSystemUsages), std::end(mSupportedSystemUsages), usage)
119 != std::end(mSupportedSystemUsages);
120}
121
Atneya Nair09859fe2024-07-15 16:38:02 -0700122Status AudioPolicyService::validateUsage(const audio_attributes_t& attr) {
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100123 return validateUsage(attr, getCallingAttributionSource());
Hayden Gomes524159d2019-12-23 14:41:47 -0800124}
125
Atneya Nair09859fe2024-07-15 16:38:02 -0700126Status AudioPolicyService::validateUsage(const audio_attributes_t& attr,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000127 const AttributionSourceState& attributionSource) {
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100128 if (isSystemUsage(attr.usage)) {
129 if (isSupportedSystemUsage(attr.usage)) {
130 if (attr.usage == AUDIO_USAGE_CALL_ASSISTANT
131 && ((attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0)) {
Atneya Nair09859fe2024-07-15 16:38:02 -0700132 if (!(audioserver_permissions() ?
133 CHECK_PERM(CALL_AUDIO_INTERCEPTION, attributionSource.uid)
134 : callAudioInterceptionAllowed(attributionSource))) {
Eric Laurentf8763482022-03-30 20:37:30 +0200135 ALOGE("%s: call audio interception not allowed for attribution source: %s",
136 __func__, attributionSource.toString().c_str());
Atneya Nair09859fe2024-07-15 16:38:02 -0700137 return Status::fromExceptionCode(Status::EX_SECURITY,
138 "Call audio interception not allowed");
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100139 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700140 } else if (!(audioserver_permissions() ?
141 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
142 : modifyAudioRoutingAllowed(attributionSource))) {
Eric Laurentf8763482022-03-30 20:37:30 +0200143 ALOGE("%s: modify audio routing not allowed for attribution source: %s",
144 __func__, attributionSource.toString().c_str());
Atneya Nair09859fe2024-07-15 16:38:02 -0700145 return Status::fromExceptionCode(Status::EX_SECURITY,
146 "Modify audio routing not allowed");
Hayden Gomes524159d2019-12-23 14:41:47 -0800147 }
148 } else {
Atneya Nair09859fe2024-07-15 16:38:02 -0700149 return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
Hayden Gomes524159d2019-12-23 14:41:47 -0800150 }
151 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700152 return Status::ok();
Hayden Gomes524159d2019-12-23 14:41:47 -0800153}
154
155
Eric Laurent2d388ec2014-03-07 13:25:54 -0800156
157// ----------------------------------------------------------------------------
158
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000159void AudioPolicyService::doOnNewAudioModulesAvailable()
160{
161 if (mAudioPolicyManager == NULL) return;
Andy Hung79eacdb2023-11-30 19:34:24 -0800162 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000163 AutoCallerClear acc;
164 mAudioPolicyManager->onNewAudioModulesAvailable();
165}
166
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800167Status AudioPolicyService::setDeviceConnectionState(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800168 media::AudioPolicyDeviceState stateAidl,
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100169 const android::media::audio::common::AudioPort& port,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700170 const AudioFormatDescription& encodedFormatAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800171 audio_policy_dev_state_t state = VALUE_OR_RETURN_BINDER_STATUS(
172 aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(stateAidl));
173 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700174 aidl2legacy_AudioFormatDescription_audio_format_t(encodedFormatAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800175
Eric Laurentdce54a12014-03-10 12:19:46 -0700176 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800177 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800178 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700179 if (!(audioserver_permissions() ?
180 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
181 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800182 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800183 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800184 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
185 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800186 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800187 }
188
189 ALOGV("setDeviceConnectionState()");
Andy Hung79eacdb2023-11-30 19:34:24 -0800190 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700191 AutoCallerClear acc;
Mikhail Naganov932cb962021-09-16 01:05:27 +0000192 status_t status = mAudioPolicyManager->setDeviceConnectionState(
Nathalie Le Clair88fa2752021-11-23 13:03:41 +0100193 state, port, encodedFormat);
Eric Laurent39095982021-08-24 18:29:27 +0200194 if (status == NO_ERROR) {
195 onCheckSpatializer_l();
196 }
197 return binderStatusFromStatusT(status);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800198}
199
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000200Status AudioPolicyService::getDeviceConnectionState(const AudioDevice& deviceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800201 media::AudioPolicyDeviceState* _aidl_return) {
Mikhail Naganov932cb962021-09-16 01:05:27 +0000202 audio_devices_t device;
203 std::string address;
204 RETURN_BINDER_STATUS_IF_ERROR(
205 aidl2legacy_AudioDevice_audio_device(deviceAidl, &device, &address));
Eric Laurentdce54a12014-03-10 12:19:46 -0700206 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800207 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
208 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
209 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
210 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800211 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800212 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700213 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800214 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
215 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
Mikhail Naganov932cb962021-09-16 01:05:27 +0000216 mAudioPolicyManager->getDeviceConnectionState(
217 device, address.c_str())));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800218 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800219}
220
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800221Status AudioPolicyService::handleDeviceConfigChange(
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000222 const AudioDevice& deviceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800223 const std::string& deviceNameAidl,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700224 const AudioFormatDescription& encodedFormatAidl) {
Mikhail Naganov932cb962021-09-16 01:05:27 +0000225 audio_devices_t device;
226 std::string address;
227 RETURN_BINDER_STATUS_IF_ERROR(
228 aidl2legacy_AudioDevice_audio_device(deviceAidl, &device, &address));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800229 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700230 aidl2legacy_AudioFormatDescription_audio_format_t(encodedFormatAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800231
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800232 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800233 return binderStatusFromStatusT(NO_INIT);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800234 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700235 if (!(audioserver_permissions() ?
236 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
237 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800238 return binderStatusFromStatusT(PERMISSION_DENIED);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800239 }
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800240
241 ALOGV("handleDeviceConfigChange()");
Andy Hung79eacdb2023-11-30 19:34:24 -0800242 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700243 AutoCallerClear acc;
Eric Laurent39095982021-08-24 18:29:27 +0200244 status_t status = mAudioPolicyManager->handleDeviceConfigChange(
Mikhail Naganov932cb962021-09-16 01:05:27 +0000245 device, address.c_str(), deviceNameAidl.c_str(), encodedFormat);
Eric Laurent39095982021-08-24 18:29:27 +0200246
247 if (status == NO_ERROR) {
248 onCheckSpatializer_l();
249 }
250 return binderStatusFromStatusT(status);
Pavlin Radoslavovf862bc62016-12-26 18:57:22 -0800251}
252
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700253Status AudioPolicyService::setPhoneState(AudioMode stateAidl, int32_t uidAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800254{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800255 audio_mode_t state = VALUE_OR_RETURN_BINDER_STATUS(
256 aidl2legacy_AudioMode_audio_mode_t(stateAidl));
257 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -0700258 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800259 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800260 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700261 if (!(audioserver_permissions() ?
262 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
263 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800264 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800265 }
266 if (uint32_t(state) >= AUDIO_MODE_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800267 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800268 }
269
270 ALOGV("setPhoneState()");
271
Eric Laurentbeb07fe2015-09-16 15:49:30 -0700272 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
273 // operation from policy manager standpoint (no other operation (e.g track start or stop)
274 // can be interleaved).
Andy Hung79eacdb2023-11-30 19:34:24 -0800275 audio_utils::lock_guard _l(mMutex);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800276 // TODO: check if it is more appropriate to do it in platform specific policy manager
Eric Laurentc8c4f1f2021-11-09 11:51:34 +0100277
278 // Audio HAL mode conversion for call redirect modes
279 audio_mode_t halMode = state;
280 if (state == AUDIO_MODE_CALL_REDIRECT) {
281 halMode = AUDIO_MODE_CALL_SCREEN;
282 } else if (state == AUDIO_MODE_COMMUNICATION_REDIRECT) {
283 halMode = AUDIO_MODE_NORMAL;
284 }
285 AudioSystem::setMode(halMode);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800286
Eric Laurent10b71232018-04-13 18:14:44 -0700287 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700288 mAudioPolicyManager->setPhoneState(state);
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700289 mPhoneState = state;
Eric Laurent00dba062020-02-11 15:52:09 -0800290 mPhoneStateOwnerUid = uid;
Mingshu Pangd07c19b2021-02-25 11:40:32 +0800291 updateUidStates_l();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800292 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800293}
294
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700295Status AudioPolicyService::getPhoneState(AudioMode* _aidl_return) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800296 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800297 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_mode_t_AudioMode(mPhoneState));
298 return Status::ok();
Eric Laurentbb6c9a02014-09-25 14:11:47 -0700299}
300
François Gaffie873738c2024-08-02 17:09:21 +0200301Status AudioPolicyService::setForceUse(AudioPolicyForceUse usageAidl,
302 AudioPolicyForcedConfig configAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800303{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800304 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
305 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
306 audio_policy_forced_cfg_t config = VALUE_OR_RETURN_BINDER_STATUS(
307 aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl));
308
Eric Laurentdce54a12014-03-10 12:19:46 -0700309 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800310 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800311 }
Eric Laurente17378d2018-05-09 14:43:01 -0700312
Atneya Nair09859fe2024-07-15 16:38:02 -0700313 if (!(audioserver_permissions() ?
314 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
315 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800316 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800317 }
Eric Laurente17378d2018-05-09 14:43:01 -0700318
Eric Laurent2d388ec2014-03-07 13:25:54 -0800319 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800320 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800321 }
322 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800323 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800324 }
325 ALOGV("setForceUse()");
Andy Hung79eacdb2023-11-30 19:34:24 -0800326 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700327 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -0700328 mAudioPolicyManager->setForceUse(usage, config);
Eric Laurent39095982021-08-24 18:29:27 +0200329 onCheckSpatializer_l();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800330 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800331}
332
François Gaffie873738c2024-08-02 17:09:21 +0200333Status AudioPolicyService::getForceUse(AudioPolicyForceUse usageAidl,
334 AudioPolicyForcedConfig* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800335 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
336 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
337
Eric Laurentdce54a12014-03-10 12:19:46 -0700338 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800339 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800340 }
341 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800342 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
343 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(AUDIO_POLICY_FORCE_NONE));
344 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800345 }
Eric Laurent10b71232018-04-13 18:14:44 -0700346 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800347 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
348 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
349 mAudioPolicyManager->getForceUse(usage)));
350 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800351}
352
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700353Status AudioPolicyService::getOutput(AudioStreamType streamAidl, int32_t* _aidl_return)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800354{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800355 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
356 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
357
Eric Laurent72af8012023-03-15 17:36:22 +0100358 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT
359 && stream != AUDIO_STREAM_ASSISTANT && stream != AUDIO_STREAM_CALL_ASSISTANT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800360 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
361 legacy2aidl_audio_io_handle_t_int32_t(AUDIO_IO_HANDLE_NONE));
362 return Status::ok();
Eric Laurentdea15412014-10-28 15:46:45 -0700363 }
Eric Laurentdce54a12014-03-10 12:19:46 -0700364 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800365 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800366 }
367 ALOGV("getOutput()");
Andy Hung79eacdb2023-11-30 19:34:24 -0800368 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700369 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800370 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
371 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutput(stream)));
372 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800373}
374
Mikhail Naganov1c400902023-05-17 11:48:43 -0700375Status AudioPolicyService::getOutputForAttr(const media::audio::common::AudioAttributes& attrAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800376 int32_t sessionAidl,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000377 const AttributionSourceState& attributionSource,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700378 const AudioConfig& configAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800379 int32_t flagsAidl,
Robert Wufb971192024-10-30 21:54:35 +0000380 const std::vector<int32_t>& selectedDeviceIdsAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800381 media::GetOutputForAttrResponse* _aidl_return)
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700382{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800383 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700384 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800385 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
386 aidl2legacy_int32_t_audio_session_t(sessionAidl));
387 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800388 audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700389 aidl2legacy_AudioConfig_audio_config_t(configAidl, false /*isInput*/));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800390 audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
391 aidl2legacy_int32_t_audio_output_flags_t_mask(flagsAidl));
Robert Wufb971192024-10-30 21:54:35 +0000392 DeviceIdVector selectedDeviceIds = VALUE_OR_RETURN_BINDER_STATUS(
393 convertContainer<DeviceIdVector>(selectedDeviceIdsAidl,
394 aidl2legacy_int32_t_audio_port_handle_t));
Eric Laurentf99edd32021-02-01 15:57:33 +0100395
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800396 audio_io_handle_t output;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800397 audio_port_handle_t portId;
398 std::vector<audio_io_handle_t> secondaryOutputs;
399
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700400 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800401 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700402 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800403
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800404 RETURN_IF_BINDER_ERROR(
405 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
Atneya Nair09859fe2024-07-15 16:38:02 -0700406 RETURN_IF_BINDER_ERROR(validateUsage(attr, attributionSource));
Hayden Gomes524159d2019-12-23 14:41:47 -0800407
Eric Laurent8a1095a2019-11-08 14:44:16 -0800408 ALOGV("%s()", __func__);
Andy Hung79eacdb2023-11-30 19:34:24 -0800409 audio_utils::lock_guard _l(mMutex);
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700410
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700411 if (!mPackageManager.allowPlaybackCapture(VALUE_OR_RETURN_BINDER_STATUS(
Eric Laurent9ff3e532022-11-10 16:04:44 +0100412 aidl2legacy_int32_t_uid_t(attributionSource.uid)))) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800413 attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
Eric Laurent42984412019-05-09 17:57:03 -0700414 }
Atneya Nair09859fe2024-07-15 16:38:02 -0700415 const bool bypassInterruptionAllowed = audioserver_permissions() ? (
416 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid) ||
417 CHECK_PERM(MODIFY_PHONE_STATE, attributionSource.uid) ||
418 CHECK_PERM(WRITE_SECURE_SETTINGS, attributionSource.uid))
419 : bypassInterruptionPolicyAllowed(attributionSource);
420
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800421 if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
Atneya Nair09859fe2024-07-15 16:38:02 -0700422 && !bypassInterruptionAllowed) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800423 attr.flags = static_cast<audio_flags_mask_t>(
424 attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
Kevin Rocard8be94972019-02-22 13:26:25 -0800425 }
Carter Hsua3abb402021-10-26 11:11:20 +0800426
427 if (attr.content_type == AUDIO_CONTENT_TYPE_ULTRASOUND) {
Atneya Nair09859fe2024-07-15 16:38:02 -0700428 if (!(audioserver_permissions() ?
429 CHECK_PERM(ACCESS_ULTRASOUND, attributionSource.uid)
430 : accessUltrasoundAllowed(attributionSource))) {
Carter Hsua3abb402021-10-26 11:11:20 +0800431 ALOGE("%s: permission denied: ultrasound not allowed for uid %d pid %d",
Eric Laurent9ff3e532022-11-10 16:04:44 +0100432 __func__, attributionSource.uid, attributionSource.pid);
Carter Hsua3abb402021-10-26 11:11:20 +0800433 return binderStatusFromStatusT(PERMISSION_DENIED);
434 }
435 }
436
Jean-Michel Trivi2dbb1a92024-11-01 22:46:25 +0000437 //TODO this permission check should extend to all system usages
438 if (attr.usage == AUDIO_USAGE_SPEAKER_CLEANUP) {
439 if (!(audioserver_permissions() ?
440 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
441 : modifyAudioRoutingAllowed())) {
442 ALOGE("%s: permission denied: SPEAKER_CLEANUP not allowed for uid %d pid %d",
443 __func__, attributionSource.uid, attributionSource.pid);
444 return binderStatusFromStatusT(PERMISSION_DENIED);
445 }
446 }
447
Eric Laurent10b71232018-04-13 18:14:44 -0700448 AutoCallerClear acc;
Eric Laurent8a1095a2019-11-08 14:44:16 -0800449 AudioPolicyInterface::output_type_t outputType;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200450 bool isSpatialized = false;
jiabinc658e452022-10-21 20:52:21 +0000451 bool isBitPerfect = false;
Andy Hung6b137d12024-08-27 22:35:17 +0000452 float volume;
Vlad Popa1e865e62024-08-15 19:11:42 -0700453 bool muted;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800454 status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
455 &stream,
Eric Laurent9ff3e532022-11-10 16:04:44 +0100456 attributionSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800457 &config,
Robert Wufb971192024-10-30 21:54:35 +0000458 &flags, &selectedDeviceIds, &portId,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800459 &secondaryOutputs,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200460 &outputType,
jiabinc658e452022-10-21 20:52:21 +0000461 &isSpatialized,
Andy Hung6b137d12024-08-27 22:35:17 +0000462 &isBitPerfect,
Vlad Popa1e865e62024-08-15 19:11:42 -0700463 &volume,
464 &muted);
Nadav Bar766fb022018-01-07 12:18:03 +0200465
466 // FIXME: Introduce a way to check for the the telephony device before opening the output
Eric Laurent8a1095a2019-11-08 14:44:16 -0800467 if (result == NO_ERROR) {
468 // enforce permission (if any) required for each type of input
469 switch (outputType) {
470 case AudioPolicyInterface::API_OUTPUT_LEGACY:
471 break;
472 case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100473 if (((attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0)
Atneya Nair09859fe2024-07-15 16:38:02 -0700474 && !(audioserver_permissions() ?
475 CHECK_PERM(CALL_AUDIO_INTERCEPTION, attributionSource.uid)
476 : callAudioInterceptionAllowed(attributionSource))) {
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100477 ALOGE("%s() permission denied: call redirection not allowed for uid %d",
Eric Laurent9ff3e532022-11-10 16:04:44 +0100478 __func__, attributionSource.uid);
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100479 result = PERMISSION_DENIED;
Atneya Nair09859fe2024-07-15 16:38:02 -0700480 } else if (!(audioserver_permissions() ?
481 CHECK_PERM(MODIFY_PHONE_STATE, attributionSource.uid)
482 : modifyPhoneStateAllowed(attributionSource))) {
Eric Laurent8a1095a2019-11-08 14:44:16 -0800483 ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
Eric Laurent9ff3e532022-11-10 16:04:44 +0100484 __func__, attributionSource.uid);
Eric Laurent8a1095a2019-11-08 14:44:16 -0800485 result = PERMISSION_DENIED;
486 }
487 break;
488 case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
Atneya Nair09859fe2024-07-15 16:38:02 -0700489 if (!(audioserver_permissions() ?
490 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
491 : modifyAudioRoutingAllowed(attributionSource))) {
Eric Laurent8a1095a2019-11-08 14:44:16 -0800492 ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
Eric Laurent9ff3e532022-11-10 16:04:44 +0100493 __func__, attributionSource.uid);
Eric Laurent8a1095a2019-11-08 14:44:16 -0800494 result = PERMISSION_DENIED;
495 }
496 break;
497 case AudioPolicyInterface::API_OUTPUT_INVALID:
498 default:
499 LOG_ALWAYS_FATAL("%s() encountered an invalid output type %d",
500 __func__, (int)outputType);
501 }
Nadav Bar766fb022018-01-07 12:18:03 +0200502 }
Eric Laurentd7fe0862018-07-14 16:48:01 -0700503
504 if (result == NO_ERROR) {
Eric Laurent528181a2024-10-30 18:32:15 +0000505 // usecase validator is disabled by default
506 if (property_get_bool("ro.audio.usecase_validator_enabled", false /* default */)) {
507 attr = VALUE_OR_RETURN_BINDER_STATUS(
508 mUsecaseValidator->verifyAudioAttributes(output, attributionSource, attr));
509 }
Eric Laurent0d13fea2022-11-04 17:12:08 +0100510
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800511 sp<AudioPlaybackClient> client =
Eric Laurent9ff3e532022-11-10 16:04:44 +0100512 new AudioPlaybackClient(attr, output, attributionSource, session,
Robert Wufb971192024-10-30 21:54:35 +0000513 portId, selectedDeviceIds, stream, isSpatialized, config.channel_mask);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800514 mAudioPlaybackClients.add(portId, client);
515
516 _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
517 legacy2aidl_audio_io_handle_t_int32_t(output));
518 _aidl_return->stream = VALUE_OR_RETURN_BINDER_STATUS(
519 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
Robert Wufb971192024-10-30 21:54:35 +0000520 _aidl_return->selectedDeviceIds = VALUE_OR_RETURN_BINDER_STATUS(
521 convertContainer<std::vector<int32_t>>(selectedDeviceIds,
522 legacy2aidl_audio_port_handle_t_int32_t));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800523 _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
524 legacy2aidl_audio_port_handle_t_int32_t(portId));
525 _aidl_return->secondaryOutputs = VALUE_OR_RETURN_BINDER_STATUS(
526 convertContainer<std::vector<int32_t>>(secondaryOutputs,
527 legacy2aidl_audio_io_handle_t_int32_t));
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200528 _aidl_return->isSpatialized = isSpatialized;
jiabinc658e452022-10-21 20:52:21 +0000529 _aidl_return->isBitPerfect = isBitPerfect;
Eric Laurent0d13fea2022-11-04 17:12:08 +0100530 _aidl_return->attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700531 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
Andy Hung6b137d12024-08-27 22:35:17 +0000532 _aidl_return->volume = volume;
Vlad Popa1e865e62024-08-15 19:11:42 -0700533 _aidl_return->muted = muted;
jiabinf1c73972022-04-14 16:28:52 -0700534 } else {
535 _aidl_return->configBase.format = VALUE_OR_RETURN_BINDER_STATUS(
536 legacy2aidl_audio_format_t_AudioFormatDescription(config.format));
537 _aidl_return->configBase.channelMask = VALUE_OR_RETURN_BINDER_STATUS(
538 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
539 config.channel_mask, false /*isInput*/));
540 _aidl_return->configBase.sampleRate = config.sample_rate;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700541 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800542 return binderStatusFromStatusT(result);
Jean-Michel Trivi5bd3f382014-06-13 16:06:54 -0700543}
544
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700545void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
546 sp<AudioPlaybackClient>& client,
547 sp<AudioPolicyEffects>& effects,
548 const char *context)
549{
Andy Hung79eacdb2023-11-30 19:34:24 -0800550 audio_utils::lock_guard _l(mMutex);
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700551 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
552 if (index < 0) {
553 ALOGE("%s AudioTrack client not found for portId %d", context, portId);
554 return;
555 }
556 client = mAudioPlaybackClients.valueAt(index);
557 effects = mAudioPolicyEffects;
558}
559
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800560Status AudioPolicyService::startOutput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800561{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800562 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
563 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -0700564 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800565 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800566 }
567 ALOGV("startOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700568 sp<AudioPlaybackClient> client;
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000569 sp<AudioPolicyEffects> audioPolicyEffects;
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700570
571 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
572
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700573 if (audioPolicyEffects != 0) {
574 // create audio processors according to stream
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000575 status_t status = audioPolicyEffects->addOutputSessionEffects(client->io, client->stream,
576 client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700577 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700578 ALOGW("Failed to add effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700579 }
580 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800581 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700582 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700583 status_t status = mAudioPolicyManager->startOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700584 if (status == NO_ERROR) {
Eric Laurent0d13fea2022-11-04 17:12:08 +0100585 //TODO b/257922898: decide if/how we need to handle attributes update when playback starts
586 // or during playback
587 (void)mUsecaseValidator->startClient(client->io, client->portId, client->attributionSource,
588 client->attributes, nullptr /* callback */);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700589 client->active = true;
Eric Laurent15903592022-02-24 20:44:36 +0100590 onUpdateActiveSpatializerTracks_l();
Eric Laurentd7fe0862018-07-14 16:48:01 -0700591 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800592 return binderStatusFromStatusT(status);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800593}
594
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800595Status AudioPolicyService::stopOutput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800596{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800597 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
598 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -0700599 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800600 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800601 }
602 ALOGV("stopOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700603 mOutputCommandThread->stopOutputCommand(portId);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800604 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800605}
606
Eric Laurentd7fe0862018-07-14 16:48:01 -0700607status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800608{
Eric Laurentd7fe0862018-07-14 16:48:01 -0700609 ALOGV("doStopOutput");
610 sp<AudioPlaybackClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700611 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700612
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700613 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
614
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700615 if (audioPolicyEffects != 0) {
616 // release audio processors from the stream
Eric Laurentd7fe0862018-07-14 16:48:01 -0700617 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
618 client->io, client->stream, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700619 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Eric Laurentd7fe0862018-07-14 16:48:01 -0700620 ALOGW("Failed to release effects on session %d", client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700621 }
622 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800623 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -0700624 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -0700625 status_t status = mAudioPolicyManager->stopOutput(portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700626 if (status == NO_ERROR) {
627 client->active = false;
Eric Laurent15903592022-02-24 20:44:36 +0100628 onUpdateActiveSpatializerTracks_l();
Eric Laurent0d13fea2022-11-04 17:12:08 +0100629 mUsecaseValidator->stopClient(client->io, client->portId);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700630 }
631 return status;
Eric Laurent2d388ec2014-03-07 13:25:54 -0800632}
633
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800634Status AudioPolicyService::releaseOutput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800635{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800636 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
637 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -0700638 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800639 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800640 }
641 ALOGV("releaseOutput()");
Eric Laurentd7fe0862018-07-14 16:48:01 -0700642 mOutputCommandThread->releaseOutputCommand(portId);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800643 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800644}
645
Eric Laurentd7fe0862018-07-14 16:48:01 -0700646void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800647{
648 ALOGV("doReleaseOutput from tid %d", gettid());
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700649 sp<AudioPlaybackClient> client;
650 sp<AudioPolicyEffects> audioPolicyEffects;
651
652 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
653
654 if (audioPolicyEffects != 0 && client->active) {
655 // clean up effects if output was not stopped before being released
656 audioPolicyEffects->releaseOutputSessionEffects(
657 client->io, client->stream, client->session);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700658 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800659 audio_utils::lock_guard _l(mMutex);
Eric Laurent15903592022-02-24 20:44:36 +0100660 if (client != nullptr && client->active) {
661 onUpdateActiveSpatializerTracks_l();
662 }
Eric Laurentd4007242019-03-27 12:42:16 -0700663 mAudioPlaybackClients.removeItem(portId);
Eric Laurent10b71232018-04-13 18:14:44 -0700664 // called from internal thread: no need to clear caller identity
Eric Laurent8fc147b2018-07-22 19:13:55 -0700665 mAudioPolicyManager->releaseOutput(portId);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800666}
667
Atneya Nair89ff0432024-11-19 12:47:28 -0800668// These are sources for which CAPTURE_AUDIO_OUTPUT granted access
669// for legacy reasons, before more specific permissions were deployed.
670// TODO: remove this access
671static bool isLegacyOutputSource(AudioSource source) {
672 switch (source) {
673 case AudioSource::VOICE_CALL:
674 case AudioSource::VOICE_DOWNLINK:
675 case AudioSource::VOICE_UPLINK:
676 case AudioSource::FM_TUNER:
677 return true;
678 default:
679 return false;
680 }
681}
682
Atneya Nairfda90e82024-11-19 19:55:25 -0800683error::BinderResult<bool> AudioPolicyService::AudioPolicyClient::checkPermissionForInput(
684 const AttributionSourceState& attrSource, const PermissionReqs& req) {
685
Atneya Nair89ff0432024-11-19 12:47:28 -0800686 error::BinderResult<bool> permRes = true;
687 const auto check_perm = [&](PermissionEnum perm, uid_t uid) {
Atneya Nairfda90e82024-11-19 19:55:25 -0800688 return mAudioPolicyService->getPermissionProvider().checkPermission(perm, uid);
Atneya Nair89ff0432024-11-19 12:47:28 -0800689 };
Atneya Nairfda90e82024-11-19 19:55:25 -0800690 switch (req.source) {
Atneya Nair89ff0432024-11-19 12:47:28 -0800691 case AudioSource::VOICE_UPLINK:
692 case AudioSource::VOICE_DOWNLINK:
693 case AudioSource::VOICE_CALL:
694 permRes = audioserver_permissions()
695 ? check_perm(CALL_AUDIO_INTERCEPTION, attrSource.uid)
696 : callAudioInterceptionAllowed(attrSource);
697 break;
698 case AudioSource::ECHO_REFERENCE:
699 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
700 : captureAudioOutputAllowed(attrSource);
701 break;
702 case AudioSource::FM_TUNER:
703 permRes = audioserver_permissions()
704 ? check_perm(CAPTURE_TUNER_AUDIO_INPUT, attrSource.uid)
705 : captureTunerAudioInputAllowed(attrSource);
706 break;
707 case AudioSource::HOTWORD:
708 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_HOTWORD, attrSource.uid)
709 : captureHotwordAllowed(attrSource);
710 break;
711 case AudioSource::ULTRASOUND:
712 permRes = audioserver_permissions() ? check_perm(ACCESS_ULTRASOUND, attrSource.uid)
713 : accessUltrasoundAllowed(attrSource);
714 break;
715 case AudioSource::SYS_RESERVED_INVALID:
716 case AudioSource::DEFAULT:
717 case AudioSource::MIC:
718 case AudioSource::CAMCORDER:
719 case AudioSource::VOICE_RECOGNITION:
720 case AudioSource::VOICE_COMMUNICATION:
721 case AudioSource::UNPROCESSED:
722 case AudioSource::VOICE_PERFORMANCE:
723 // No additional check intended
724 case AudioSource::REMOTE_SUBMIX:
Atneya Nairfda90e82024-11-19 19:55:25 -0800725 // special-case checked based on mix type below
Atneya Nair89ff0432024-11-19 12:47:28 -0800726 break;
727 }
728
Atneya Nairfda90e82024-11-19 19:55:25 -0800729 if (!permRes.has_value()) return permRes;
730 if (!permRes.value()) {
731 if (isLegacyOutputSource(req.source)) {
Atneya Nair89ff0432024-11-19 12:47:28 -0800732 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
733 : captureAudioOutputAllowed(attrSource);
734 PROPAGATE_FALSEY(permRes);
735 } else {
736 return false;
737 }
738 }
739
Atneya Nairfda90e82024-11-19 19:55:25 -0800740 if (req.isHotword) {
Atneya Nair89ff0432024-11-19 12:47:28 -0800741 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_HOTWORD, attrSource.uid)
742 : captureHotwordAllowed(attrSource);
743 PROPAGATE_FALSEY(permRes);
744 }
745
Atneya Nairfda90e82024-11-19 19:55:25 -0800746 // TODO evaluate whether we should be checking call redirection like this
Atneya Nair89ff0432024-11-19 12:47:28 -0800747 bool isAllowedDueToCallPerm = false;
Atneya Nairfda90e82024-11-19 19:55:25 -0800748 if (req.isCallRedir) {
Atneya Nair89ff0432024-11-19 12:47:28 -0800749 const auto checkCall = audioserver_permissions()
Atneya Nairfda90e82024-11-19 19:55:25 -0800750 ? check_perm(CALL_AUDIO_INTERCEPTION, attrSource.uid)
751 : callAudioInterceptionAllowed(attrSource);
Atneya Nair89ff0432024-11-19 12:47:28 -0800752 isAllowedDueToCallPerm = VALUE_OR_RETURN(checkCall);
753 }
Atneya Nairfda90e82024-11-19 19:55:25 -0800754
755 switch (req.mixType) {
756 case MixType::NONE:
757 break;
758 case MixType::PUBLIC_CAPTURE_PLAYBACK:
Atneya Nair89ff0432024-11-19 12:47:28 -0800759 // this use case has been validated in audio service with a MediaProjection token,
760 // and doesn't rely on regular permissions
Atneya Nairfda90e82024-11-19 19:55:25 -0800761 // TODO (b/378778313)
Atneya Nair89ff0432024-11-19 12:47:28 -0800762 break;
Atneya Nairfda90e82024-11-19 19:55:25 -0800763 case MixType::TELEPHONY_RX_CAPTURE:
Atneya Nair89ff0432024-11-19 12:47:28 -0800764 if (isAllowedDueToCallPerm) break;
765 // FIXME: use the same permission as for remote submix for now.
766 FALLTHROUGH_INTENDED;
Atneya Nairfda90e82024-11-19 19:55:25 -0800767 case MixType::CAPTURE:
Atneya Nair89ff0432024-11-19 12:47:28 -0800768 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
769 : captureAudioOutputAllowed(attrSource);
770 break;
Atneya Nairfda90e82024-11-19 19:55:25 -0800771 case MixType::EXT_POLICY_REROUTE:
Atneya Nair89ff0432024-11-19 12:47:28 -0800772 // TODO intended?
773 if (isAllowedDueToCallPerm) break;
774 permRes = audioserver_permissions() ? check_perm(MODIFY_AUDIO_ROUTING, attrSource.uid)
775 : modifyAudioRoutingAllowed(attrSource);
776 break;
Atneya Nair89ff0432024-11-19 12:47:28 -0800777 }
778
779 PROPAGATE_FALSEY(permRes);
780
Atneya Nairfda90e82024-11-19 19:55:25 -0800781 // All sources which aren't output capture
782 // AND capture from vdi policy mix (the injected audio is mic data from another device)
783 // REQUIRE RECORD perms
784 const auto legacySource = aidl2legacy_AudioSource_audio_source_t(req.source).value();
785 if (req.virtualDeviceId != kDefaultVirtualDeviceId) {
786 // TODO assert that this is always a recordOpSource
787 // TODO upcall solution
788 return recordingAllowed(attrSource, req.virtualDeviceId, legacySource);
789 }
790
791 if (isRecordOpRequired(legacySource)) {
792 permRes = audioserver_permissions() ? check_perm(RECORD_AUDIO, attrSource.uid)
793 : recordingAllowed(attrSource, legacySource);
794 PROPAGATE_FALSEY(permRes);
Atneya Nair89ff0432024-11-19 12:47:28 -0800795 }
796 return true;
797}
798
Mikhail Naganov1c400902023-05-17 11:48:43 -0700799Status AudioPolicyService::getInputForAttr(const media::audio::common::AudioAttributes& attrAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800800 int32_t inputAidl,
801 int32_t riidAidl,
802 int32_t sessionAidl,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000803 const AttributionSourceState& attributionSource,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700804 const AudioConfigBase& configAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800805 int32_t flagsAidl,
Eric Laurentf99edd32021-02-01 15:57:33 +0100806 int32_t selectedDeviceIdAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800807 media::GetInputForAttrResponse* _aidl_return) {
Atneya Nair89ff0432024-11-19 12:47:28 -0800808 auto inputSource = attrAidl.source;
Atneya Nair25fbcf22024-11-19 19:53:23 -0800809 const audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700810 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800811 const audio_io_handle_t requestedInput = VALUE_OR_RETURN_BINDER_STATUS(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800812 aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800813 const audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800814 aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800815 const audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800816 aidl2legacy_int32_t_audio_session_t(sessionAidl));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800817 const audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700818 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl, true /*isInput*/));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800819 const audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800820 aidl2legacy_int32_t_audio_input_flags_t_mask(flagsAidl));
Atneya Nair25fbcf22024-11-19 19:53:23 -0800821 const audio_port_handle_t requestedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
Eric Laurentf99edd32021-02-01 15:57:33 +0100822 aidl2legacy_int32_t_audio_port_handle_t(selectedDeviceIdAidl));
823
Eric Laurentdce54a12014-03-10 12:19:46 -0700824 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800825 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800826 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800827
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800828 RETURN_IF_BINDER_ERROR(
829 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
Hayden Gomes524159d2019-12-23 14:41:47 -0800830
Atneya Nair89ff0432024-11-19 12:47:28 -0800831 if (inputSource == AudioSource::SYS_RESERVED_INVALID ||
832 std::find(enum_range<AudioSource>().begin(), enum_range<AudioSource>().end(),
833 inputSource) == enum_range<AudioSource>().end()) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800834 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800835 }
836
Atneya Nair89ff0432024-11-19 12:47:28 -0800837 if (inputSource == AudioSource::DEFAULT) {
838 inputSource = AudioSource::MIC;
Eric Laurent7dca8a82018-01-29 18:44:26 -0800839 }
840
Atneya Nair89ff0432024-11-19 12:47:28 -0800841 const bool isCallRedir = (attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0;
842
Eric Laurentdbb80322024-11-18 16:09:51 -0800843 //TODO(b/374751406): remove forcing canBypassConcurrentPolicy to canCaptureOutput
844 // once all system apps using CAPTURE_AUDIO_OUTPUT to capture during calls
845 // are updated to use the new CONCURRENT_AUDIO_RECORD_BYPASS permission.
Atneya Nairfda90e82024-11-19 19:55:25 -0800846 bool canBypassConcurrentPolicy = audioserver_permissions()
847 ? CHECK_PERM(CAPTURE_AUDIO_OUTPUT, attributionSource.uid)
848 : captureAudioOutputAllowed(attributionSource);
Eric Laurentdbb80322024-11-18 16:09:51 -0800849 if (concurrent_audio_record_bypass_permission()) {
850 canBypassConcurrentPolicy = audioserver_permissions() ?
851 CHECK_PERM(BYPASS_CONCURRENT_RECORD_AUDIO_RESTRICTION,
852 attributionSource.uid)
853 : bypassConcurrentPolicyAllowed(attributionSource);
854 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100855
Atneya Nair25fbcf22024-11-19 19:53:23 -0800856 sp<AudioPolicyEffects> audioPolicyEffects;
857 base::expected<media::GetInputForAttrResponse, std::variant<binder::Status, AudioConfigBase>>
858 res;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700859 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800860 audio_utils::lock_guard _l(mMutex);
Atneya Nairfda90e82024-11-19 19:55:25 -0800861 AutoCallerClear acc;
862 // the audio_in_acoustics_t parameter is ignored by get_input()
863 res = mAudioPolicyManager->getInputForAttr(attr, requestedInput, requestedDeviceId,
864 config, flags, riid, session,
865 attributionSource);
Atneya Nair25fbcf22024-11-19 19:53:23 -0800866 if (!res.has_value()) {
867 if (res.error().index() == 1) {
868 _aidl_return->config = std::get<1>(res.error());
869 return Status::fromExceptionCode(EX_ILLEGAL_STATE);
870 } else {
871 return std::get<0>(res.error());
872 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800873 }
Eric Laurentfee19762018-01-29 18:44:13 -0800874
Atneya Nairfda90e82024-11-19 19:55:25 -0800875 audioPolicyEffects = mAudioPolicyEffects;
876
877 sp<AudioRecordClient> client = new AudioRecordClient(
878 attr, res->input, session, res->portId, {res->selectedDeviceId}, attributionSource,
879 res->virtualDeviceId, canBypassConcurrentPolicy, mOutputCommandThread);
Atneya Nair25fbcf22024-11-19 19:53:23 -0800880 mAudioRecordClients.add(res->portId, client);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700881 }
Jean-Michel Trivi97bb33f2014-12-12 16:23:43 -0800882
Atneya Nairfda90e82024-11-19 19:55:25 -0800883 if (audioPolicyEffects != nullptr) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700884 // create audio pre processors according to input source
Atneya Nair25fbcf22024-11-19 19:53:23 -0800885 status_t status = audioPolicyEffects->addInputEffects(res->input,
Atneya Nair89ff0432024-11-19 12:47:28 -0800886 aidl2legacy_AudioSource_audio_source_t(inputSource).value(), session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700887 if (status != NO_ERROR && status != ALREADY_EXISTS) {
Atneya Nair25fbcf22024-11-19 19:53:23 -0800888 ALOGW("Failed to add effects on input %d", res->input);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700889 }
Eric Laurent2d388ec2014-03-07 13:25:54 -0800890 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800891
Atneya Nair25fbcf22024-11-19 19:53:23 -0800892 *_aidl_return = res.value();
893
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800894 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -0800895}
896
Eric Laurent99fcae42018-05-17 16:59:18 -0700897std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
jiabin19cdba52020-11-24 11:28:58 -0800898 struct audio_port_v7 port = {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700899 port.id = portId;
900 status_t status = mAudioPolicyManager->getAudioPort(&port);
901 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
Andy Hung9b181952019-02-25 14:53:36 -0800902 return toString(port.ext.device.type);
Eric Laurent99fcae42018-05-17 16:59:18 -0700903 }
Andy Hung9b181952019-02-25 14:53:36 -0800904 return {};
Eric Laurent99fcae42018-05-17 16:59:18 -0700905}
906
Robert Wufb971192024-10-30 21:54:35 +0000907std::string AudioPolicyService::getDeviceTypeStrForPortIds(DeviceIdVector portIds) {
908 std::string output = {};
909 for (auto it = portIds.begin(); it != portIds.end(); ++it) {
910 if (it != portIds.begin()) {
911 output += ", ";
912 }
913 output += getDeviceTypeStrForPortId(*it);
914 }
915 return output;
916}
917
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800918Status AudioPolicyService::startInput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -0800919{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800920 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
921 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
922
Eric Laurentdce54a12014-03-10 12:19:46 -0700923 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800924 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -0800925 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800926 sp<AudioRecordClient> client;
927 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800928 audio_utils::lock_guard _l(mMutex);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800929
Eric Laurent7dca8a82018-01-29 18:44:26 -0800930 ssize_t index = mAudioRecordClients.indexOfKey(portId);
931 if (index < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800932 return binderStatusFromStatusT(INVALID_OPERATION);
Eric Laurent7dca8a82018-01-29 18:44:26 -0800933 }
934 client = mAudioRecordClients.valueAt(index);
Eric Laurentfee19762018-01-29 18:44:13 -0800935 }
Eric Laurent7dca8a82018-01-29 18:44:26 -0800936
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700937 std::stringstream msg;
938 msg << "Audio recording on session " << client->session;
Atneya Nair38558e12024-10-25 17:59:36 -0700939
Atneya Nairdb6ef1e2024-09-16 20:26:30 +0000940 const auto permitted = startRecording(client->attributionSource, client->virtualDeviceId,
941 String16(msg.str().c_str()), client->attributes.source);
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700942
Eric Laurent7dca8a82018-01-29 18:44:26 -0800943 // check calling permissions
Atneya Nair38558e12024-10-25 17:59:36 -0700944 if (permitted == PERMISSION_HARD_DENIED) {
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000945 ALOGE("%s permission denied: recording not allowed for attribution source %s",
946 __func__, client->attributionSource.toString().c_str());
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800947 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent7dca8a82018-01-29 18:44:26 -0800948 }
Eric Laurentfee19762018-01-29 18:44:13 -0800949
Andy Hung79eacdb2023-11-30 19:34:24 -0800950 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800951
Atneya Naire7720b32023-05-10 17:26:30 -0700952 ALOGW_IF(client->silenced, "startInput on silenced input for port %d, uid %d. Unsilencing.",
953 portIdAidl,
954 client->attributionSource.uid);
955
956 if (client->active) {
957 ALOGE("Client should never be active before startInput. Uid %d port %d",
958 client->attributionSource.uid, portId);
Marvin Raminb03b49f2024-04-04 16:25:31 +0200959 finishRecording(client->attributionSource, client->virtualDeviceId,
960 client->attributes.source);
Atneya Naire7720b32023-05-10 17:26:30 -0700961 return binderStatusFromStatusT(INVALID_OPERATION);
962 }
963
Atneya Nairdb6ef1e2024-09-16 20:26:30 +0000964 // Force the possibly silenced client to match the state on the appops side
965 // following the call to startRecording (i.e. unsilenced iff call succeeded)
966 // At this point in time, the client is inactive, so no calls to appops are
967 // sent in setAppState_l. This ensures existing clients have the same
968 // behavior as new clients.
Atneya Naire7720b32023-05-10 17:26:30 -0700969 // TODO(b/282076713)
Atneya Nairdb6ef1e2024-09-16 20:26:30 +0000970 if (permitted == PERMISSION_GRANTED) {
971 setAppState_l(client, APP_STATE_TOP);
972 } else {
973 setAppState_l(client, APP_STATE_IDLE);
974 }
Atneya Naire7720b32023-05-10 17:26:30 -0700975
Eric Laurent4eb58f12018-12-07 16:41:02 -0800976 client->active = true;
977 client->startTimeNs = systemTime();
Atneya Naire7720b32023-05-10 17:26:30 -0700978 // This call updates the silenced state, and since we are active, appropriately notifies appops
979 // if we silence the track.
Eric Laurent4eb58f12018-12-07 16:41:02 -0800980 updateUidStates_l();
Eric Laurentfee19762018-01-29 18:44:13 -0800981
Eric Laurent10b71232018-04-13 18:14:44 -0700982 status_t status;
983 {
984 AutoCallerClear acc;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800985 status = mAudioPolicyManager->startInput(portId);
Ray Essick84e84a52018-05-03 18:45:07 -0700986
987 }
988
Ray Essickf6a57cd2018-05-22 16:20:54 -0700989 // including successes gets very verbose
Muhammad Qureshi087b37c2020-06-16 16:37:36 -0700990 // but once we cut over to statsd, log them all.
Ray Essickf6a57cd2018-05-22 16:20:54 -0700991 if (status != NO_ERROR) {
Ray Essick84e84a52018-05-03 18:45:07 -0700992
993 static constexpr char kAudioPolicy[] = "audiopolicy";
994
Ray Essick84e84a52018-05-03 18:45:07 -0700995 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
996 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
997 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
998 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
Eric Laurent99fcae42018-05-17 16:59:18 -0700999 static constexpr char kAudioPolicyRqstDevice[] =
1000 "android.media.audiopolicy.rqst.device";
Ray Essick84e84a52018-05-03 18:45:07 -07001001 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
1002 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
Eric Laurent99fcae42018-05-17 16:59:18 -07001003 static constexpr char kAudioPolicyActiveSession[] =
1004 "android.media.audiopolicy.active.session";
1005 static constexpr char kAudioPolicyActiveDevice[] =
1006 "android.media.audiopolicy.active.device";
Robert Wufb971192024-10-30 21:54:35 +00001007 static constexpr char kAudioPolicyActiveDevices[] =
1008 "android.media.audiopolicy.active.devices";
Ray Essick84e84a52018-05-03 18:45:07 -07001009
Ray Essickf27e9872019-12-07 06:28:46 -08001010 mediametrics::Item *item = mediametrics::Item::create(kAudioPolicy);
Ray Essick84e84a52018-05-03 18:45:07 -07001011 if (item != NULL) {
1012
Ray Essick84e84a52018-05-03 18:45:07 -07001013 item->setInt32(kAudioPolicyStatus, status);
1014
Eric Laurent99fcae42018-05-17 16:59:18 -07001015 item->setCString(kAudioPolicyRqstSrc,
Andy Hung9b181952019-02-25 14:53:36 -08001016 toString(client->attributes.source).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -07001017 item->setInt32(kAudioPolicyRqstSession, client->session);
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001018 if (client->attributionSource.packageName.has_value() &&
1019 client->attributionSource.packageName.value().size() != 0) {
Ray Essick51866952018-05-30 11:22:27 -07001020 item->setCString(kAudioPolicyRqstPkg,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001021 client->attributionSource.packageName.value().c_str());
Ray Essick51866952018-05-30 11:22:27 -07001022 } else {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001023 item->setCString(kAudioPolicyRqstPkg,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001024 std::to_string(client->attributionSource.uid).c_str());
Ray Essick51866952018-05-30 11:22:27 -07001025 }
Robert Wufb971192024-10-30 21:54:35 +00001026 item->setCString(kAudioPolicyRqstDevice,
1027 getDeviceTypeStrForPortId(getFirstDeviceId(client->deviceIds)).c_str());
Eric Laurent99fcae42018-05-17 16:59:18 -07001028
Eric Laurent4eb58f12018-12-07 16:41:02 -08001029 int count = mAudioRecordClients.size();
1030 for (int i = 0; i < count ; i++) {
1031 if (portId == mAudioRecordClients.keyAt(i)) {
1032 continue;
1033 }
1034 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
1035 if (other->active) {
1036 // keeps the last of the clients marked active
1037 item->setCString(kAudioPolicyActiveSrc,
Andy Hung9b181952019-02-25 14:53:36 -08001038 toString(other->attributes.source).c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -08001039 item->setInt32(kAudioPolicyActiveSession, other->session);
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001040 if (other->attributionSource.packageName.has_value() &&
1041 other->attributionSource.packageName.value().size() != 0) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001042 item->setCString(kAudioPolicyActivePkg,
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001043 other->attributionSource.packageName.value().c_str());
Eric Laurent4eb58f12018-12-07 16:41:02 -08001044 } else {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001045 item->setCString(kAudioPolicyRqstPkg, std::to_string(
Svet Ganov3e5f14f2021-05-13 22:51:08 +00001046 other->attributionSource.uid).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -07001047 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001048 item->setCString(kAudioPolicyActiveDevice,
Robert Wufb971192024-10-30 21:54:35 +00001049 getDeviceTypeStrForPortId(getFirstDeviceId(other->deviceIds)).c_str());
1050 item->setCString(kAudioPolicyActiveDevices,
1051 getDeviceTypeStrForPortIds(other->deviceIds).c_str());
Ray Essick84e84a52018-05-03 18:45:07 -07001052 }
1053 }
1054 item->selfrecord();
1055 delete item;
1056 item = NULL;
1057 }
Ray Essick6ce27e52019-02-15 10:58:05 -08001058 }
1059
1060 if (status != NO_ERROR) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001061 client->active = false;
1062 client->startTimeNs = 0;
1063 updateUidStates_l();
Atneya Nairdb6ef1e2024-09-16 20:26:30 +00001064 if (!client->silenced) {
1065 finishRecording(client->attributionSource, client->virtualDeviceId,
1066 client->attributes.source);
1067 }
Eric Laurentfb66dd92016-01-28 18:32:03 -08001068 }
1069
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001070 return binderStatusFromStatusT(status);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001071}
1072
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001073Status AudioPolicyService::stopInput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -08001074{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001075 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
1076 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
1077
Eric Laurentdce54a12014-03-10 12:19:46 -07001078 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001079 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001080 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001081
Andy Hung79eacdb2023-11-30 19:34:24 -08001082 audio_utils::lock_guard _l(mMutex);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001083
Eric Laurentfee19762018-01-29 18:44:13 -08001084 ssize_t index = mAudioRecordClients.indexOfKey(portId);
1085 if (index < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001086 return binderStatusFromStatusT(INVALID_OPERATION);
Eric Laurentfee19762018-01-29 18:44:13 -08001087 }
1088 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
1089
Ray Essick84e84a52018-05-03 18:45:07 -07001090 client->active = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001091 client->startTimeNs = 0;
1092
1093 updateUidStates_l();
Ray Essick84e84a52018-05-03 18:45:07 -07001094
Svet Ganov6e641372018-03-02 09:21:30 -08001095 // finish the recording app op
Atneya Nairdb6ef1e2024-09-16 20:26:30 +00001096 if (!client->silenced) {
1097 finishRecording(client->attributionSource, client->virtualDeviceId,
1098 client->attributes.source);
1099 }
1100
Eric Laurent10b71232018-04-13 18:14:44 -07001101 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001102 return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
Eric Laurent2d388ec2014-03-07 13:25:54 -08001103}
1104
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001105Status AudioPolicyService::releaseInput(int32_t portIdAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -08001106{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001107 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
1108 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
1109
Eric Laurentdce54a12014-03-10 12:19:46 -07001110 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001111 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001112 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001113 sp<AudioPolicyEffects>audioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -08001114 sp<AudioRecordClient> client;
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001115 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001116 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001117 audioPolicyEffects = mAudioPolicyEffects;
Eric Laurentfee19762018-01-29 18:44:13 -08001118 ssize_t index = mAudioRecordClients.indexOfKey(portId);
1119 if (index < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001120 return Status::ok();
Eric Laurentfee19762018-01-29 18:44:13 -08001121 }
1122 client = mAudioRecordClients.valueAt(index);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001123
1124 if (client->active) {
1125 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
1126 client->active = false;
1127 client->startTimeNs = 0;
1128 updateUidStates_l();
1129 }
1130
Eric Laurentfee19762018-01-29 18:44:13 -08001131 mAudioRecordClients.removeItem(portId);
1132 }
1133 if (client == 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001134 return Status::ok();
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001135 }
1136 if (audioPolicyEffects != 0) {
1137 // release audio processors from the input
Eric Laurentd7fe0862018-07-14 16:48:01 -07001138 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001139 if(status != NO_ERROR) {
Eric Laurentd7fe0862018-07-14 16:48:01 -07001140 ALOGW("Failed to release effects on input %d", client->io);
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001141 }
Eric Laurent2d388ec2014-03-07 13:25:54 -08001142 }
Eric Laurentf10c7092016-12-06 17:09:56 -08001143 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001144 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001145 AutoCallerClear acc;
Eric Laurent8fc147b2018-07-22 19:13:55 -07001146 mAudioPolicyManager->releaseInput(portId);
Eric Laurentf10c7092016-12-06 17:09:56 -08001147 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001148 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001149}
1150
Vlad Popa87e0e582024-05-20 18:49:20 -07001151Status AudioPolicyService::setDeviceAbsoluteVolumeEnabled(const AudioDevice& deviceAidl,
1152 bool enabled,
1153 AudioStreamType streamToDriveAbsAidl) {
Vlad Popa08502d82024-10-22 20:17:47 -07001154 ALOGI("%s: deviceAidl %s, enabled %d, streamToDriveAbsAidl %d", __func__,
1155 deviceAidl.toString().c_str(), enabled, streamToDriveAbsAidl);
1156
Vlad Popae2c51382024-10-22 21:07:42 -07001157 audio_stream_type_t streamToDriveAbs = AUDIO_STREAM_DEFAULT;
1158 if (enabled) {
1159 streamToDriveAbs = VALUE_OR_RETURN_BINDER_STATUS(
1160 aidl2legacy_AudioStreamType_audio_stream_type_t(streamToDriveAbsAidl));
1161 }
1162
Vlad Popa87e0e582024-05-20 18:49:20 -07001163 audio_devices_t deviceType;
1164 std::string address;
1165 RETURN_BINDER_STATUS_IF_ERROR(
1166 aidl2legacy_AudioDevice_audio_device(deviceAidl, &deviceType, &address));
1167
1168 if (mAudioPolicyManager == nullptr) {
1169 return binderStatusFromStatusT(NO_INIT);
1170 }
Atneya Nair09859fe2024-07-15 16:38:02 -07001171 if (!(audioserver_permissions() ?
1172 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1173 : settingsAllowed())) {
Vlad Popa87e0e582024-05-20 18:49:20 -07001174 return binderStatusFromStatusT(PERMISSION_DENIED);
1175 }
Vlad Popae2c51382024-10-22 21:07:42 -07001176
Vlad Popa87e0e582024-05-20 18:49:20 -07001177 audio_utils::lock_guard _l(mMutex);
1178 AutoCallerClear acc;
1179 return binderStatusFromStatusT(
1180 mAudioPolicyManager->setDeviceAbsoluteVolumeEnabled(deviceType, address.c_str(),
1181 enabled, streamToDriveAbs));
1182}
1183
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001184Status AudioPolicyService::initStreamVolume(AudioStreamType streamAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001185 int32_t indexMinAidl,
1186 int32_t indexMaxAidl) {
1187 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1188 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1189 int indexMin = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMinAidl));
1190 int indexMax = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMaxAidl));
1191
Eric Laurentdce54a12014-03-10 12:19:46 -07001192 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001193 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001194 }
Atneya Nair09859fe2024-07-15 16:38:02 -07001195 if (!(audioserver_permissions() ?
1196 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1197 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001198 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001199 }
Eric Laurent223fd5c2014-11-11 13:43:36 -08001200 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001201 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001202 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001203 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001204 AutoCallerClear acc;
Eric Laurentdce54a12014-03-10 12:19:46 -07001205 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001206 return binderStatusFromStatusT(NO_ERROR);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001207}
1208
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001209Status AudioPolicyService::setStreamVolumeIndex(AudioStreamType streamAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00001210 const AudioDeviceDescription& deviceAidl,
Vlad Popa1e865e62024-08-15 19:11:42 -07001211 int32_t indexAidl, bool muted) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001212 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1213 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1214 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
1215 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001216 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001217
Eric Laurentdce54a12014-03-10 12:19:46 -07001218 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001219 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001220 }
Atneya Nair09859fe2024-07-15 16:38:02 -07001221 if (!(audioserver_permissions() ?
1222 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1223 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001224 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001225 }
Eric Laurent223fd5c2014-11-11 13:43:36 -08001226 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001227 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001228 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001229 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001230 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001231 return binderStatusFromStatusT(mAudioPolicyManager->setStreamVolumeIndex(stream,
1232 index,
Vlad Popa1e865e62024-08-15 19:11:42 -07001233 muted,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001234 device));
Eric Laurent2d388ec2014-03-07 13:25:54 -08001235}
1236
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001237Status AudioPolicyService::getStreamVolumeIndex(AudioStreamType streamAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00001238 const AudioDeviceDescription& deviceAidl,
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001239 int32_t* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001240 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1241 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1242 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001243 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001244 int index;
1245
Eric Laurentdce54a12014-03-10 12:19:46 -07001246 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001247 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001248 }
Eric Laurent223fd5c2014-11-11 13:43:36 -08001249 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001250 return binderStatusFromStatusT(BAD_VALUE);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001251 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001252 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001253 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001254 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1255 mAudioPolicyManager->getStreamVolumeIndex(stream, &index, device)));
1256 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1257 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001258}
1259
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001260Status AudioPolicyService::setVolumeIndexForAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001261 const media::audio::common::AudioAttributes& attrAidl,
Vlad Popa1e865e62024-08-15 19:11:42 -07001262 const AudioDeviceDescription& deviceAidl, int32_t indexAidl, bool muted) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001263 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001264 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001265 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
1266 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001267 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001268 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1269 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1270
François Gaffiecfe17322018-11-07 13:41:29 +01001271 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001272 return binderStatusFromStatusT(NO_INIT);
François Gaffiecfe17322018-11-07 13:41:29 +01001273 }
Atneya Nair09859fe2024-07-15 16:38:02 -07001274 if (!(audioserver_permissions() ?
1275 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1276 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001277 return binderStatusFromStatusT(PERMISSION_DENIED);
François Gaffiecfe17322018-11-07 13:41:29 +01001278 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001279 audio_utils::lock_guard _l(mMutex);
François Gaffiecfe17322018-11-07 13:41:29 +01001280 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001281 return binderStatusFromStatusT(
Vlad Popa1e865e62024-08-15 19:11:42 -07001282 mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, muted, device));
François Gaffiecfe17322018-11-07 13:41:29 +01001283}
1284
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001285Status AudioPolicyService::getVolumeIndexForAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001286 const media::audio::common::AudioAttributes& attrAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00001287 const AudioDeviceDescription& deviceAidl, int32_t* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001288 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001289 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001290 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001291 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001292 int index;
1293 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1294 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1295
François Gaffiecfe17322018-11-07 13:41:29 +01001296 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001297 return binderStatusFromStatusT(NO_INIT);
François Gaffiecfe17322018-11-07 13:41:29 +01001298 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001299 audio_utils::lock_guard _l(mMutex);
François Gaffiecfe17322018-11-07 13:41:29 +01001300 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001301 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1302 mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device)));
1303 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1304 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +01001305}
1306
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001307Status AudioPolicyService::getMinVolumeIndexForAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001308 const media::audio::common::AudioAttributes& attrAidl, int32_t* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001309 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001310 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001311 int index;
1312 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1313 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1314
François Gaffiecfe17322018-11-07 13:41:29 +01001315 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001316 return binderStatusFromStatusT(NO_INIT);
François Gaffiecfe17322018-11-07 13:41:29 +01001317 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001318 audio_utils::lock_guard _l(mMutex);
François Gaffiecfe17322018-11-07 13:41:29 +01001319 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001320 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1321 mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index)));
1322 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1323 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +01001324}
1325
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001326Status AudioPolicyService::getMaxVolumeIndexForAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001327 const media::audio::common::AudioAttributes& attrAidl, int32_t* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001328 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001329 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001330 int index;
1331 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1332 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1333
François Gaffiecfe17322018-11-07 13:41:29 +01001334 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001335 return binderStatusFromStatusT(NO_INIT);
François Gaffiecfe17322018-11-07 13:41:29 +01001336 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001337 audio_utils::lock_guard _l(mMutex);
François Gaffiecfe17322018-11-07 13:41:29 +01001338 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001339 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1340 mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index)));
1341 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1342 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +01001343}
1344
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001345Status AudioPolicyService::getStrategyForStream(AudioStreamType streamAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001346 int32_t* _aidl_return) {
1347 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1348 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1349
Eric Laurent223fd5c2014-11-11 13:43:36 -08001350 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001351 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1352 convertReinterpret<int32_t>(PRODUCT_STRATEGY_NONE));
1353 return Status::ok();
Eric Laurentdea15412014-10-28 15:46:45 -07001354 }
Eric Laurentdce54a12014-03-10 12:19:46 -07001355 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001356 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001357 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001358
François Gaffiec005e562018-11-06 15:04:49 +01001359 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
Eric Laurent10b71232018-04-13 18:14:44 -07001360 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001361 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1362 legacy2aidl_product_strategy_t_int32_t(
1363 mAudioPolicyManager->getStrategyForStream(stream)));
1364 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001365}
1366
Mikhail Naganov1c400902023-05-17 11:48:43 -07001367Status AudioPolicyService::getDevicesForAttributes(
1368 const media::audio::common::AudioAttributes& attrAidl,
1369 bool forVolume,
1370 std::vector<AudioDevice>* _aidl_return)
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001371{
François Gaffie1e2b56f2022-04-01 14:34:29 +02001372 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001373 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001374 AudioDeviceTypeAddrVector devices;
1375
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001376 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001377 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001378 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001379 audio_utils::lock_guard _l(mMutex);
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001380 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001381 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
François Gaffie1e2b56f2022-04-01 14:34:29 +02001382 mAudioPolicyManager->getDevicesForAttributes(aa, &devices, forVolume)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001383 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovf4a75362021-09-16 00:02:54 +00001384 convertContainer<std::vector<AudioDevice>>(devices,
1385 legacy2aidl_AudioDeviceTypeAddress));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001386 return Status::ok();
Jean-Michel Trivif41599b2020-01-07 14:22:08 -08001387}
1388
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001389Status AudioPolicyService::getOutputForEffect(const media::EffectDescriptor& descAidl,
1390 int32_t* _aidl_return) {
1391 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1392 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1393 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1394 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1395
Eric Laurentdce54a12014-03-10 12:19:46 -07001396 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001397 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001398 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001399 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001400 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001401 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1402 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutputForEffect(&desc)));
1403 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001404}
1405
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001406Status AudioPolicyService::registerEffect(const media::EffectDescriptor& descAidl, int32_t ioAidl,
1407 int32_t strategyAidl, int32_t sessionAidl,
1408 int32_t idAidl) {
1409 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1410 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1411 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1412 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1413 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
1414 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
1415 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
1416 aidl2legacy_int32_t_audio_session_t(sessionAidl));
1417 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1418 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1419 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1420
Eric Laurentdce54a12014-03-10 12:19:46 -07001421 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001422 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001423 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001424 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001425 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001426 return binderStatusFromStatusT(
1427 mAudioPolicyManager->registerEffect(&desc, io, strategy, session, id));
Eric Laurent2d388ec2014-03-07 13:25:54 -08001428}
1429
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001430Status AudioPolicyService::unregisterEffect(int32_t idAidl)
Eric Laurent2d388ec2014-03-07 13:25:54 -08001431{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001432 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -07001433 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001434 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001435 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001436 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001437 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001438 return binderStatusFromStatusT(mAudioPolicyManager->unregisterEffect(id));
Eric Laurent2d388ec2014-03-07 13:25:54 -08001439}
1440
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001441Status AudioPolicyService::setEffectEnabled(int32_t idAidl, bool enabled)
Eric Laurent2d388ec2014-03-07 13:25:54 -08001442{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001443 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -07001444 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001445 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001446 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001447 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001448 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001449 return binderStatusFromStatusT(mAudioPolicyManager->setEffectEnabled(id, enabled));
Eric Laurent2d388ec2014-03-07 13:25:54 -08001450}
1451
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001452Status AudioPolicyService::moveEffectsToIo(const std::vector<int32_t>& idsAidl, int32_t ioAidl)
1453
Eric Laurent6c796322019-04-09 14:13:17 -07001454{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001455 const std::vector<int>& ids = VALUE_OR_RETURN_BINDER_STATUS(
1456 convertContainer<std::vector<int>>(idsAidl, convertReinterpret<int, int32_t>));
1457 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1458 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1459 if (ids.size() > MAX_ITEMS_PER_LIST) {
1460 return binderStatusFromStatusT(BAD_VALUE);
1461 }
1462
Eric Laurent6c796322019-04-09 14:13:17 -07001463 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001464 return binderStatusFromStatusT(NO_INIT);
Eric Laurent6c796322019-04-09 14:13:17 -07001465 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001466 audio_utils::lock_guard _l(mMutex);
Eric Laurent6c796322019-04-09 14:13:17 -07001467 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001468 return binderStatusFromStatusT(mAudioPolicyManager->moveEffectsToIo(ids, io));
Eric Laurent6c796322019-04-09 14:13:17 -07001469}
1470
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001471Status AudioPolicyService::isStreamActive(AudioStreamType streamAidl, int32_t inPastMsAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001472 bool* _aidl_return) {
1473 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1474 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1475 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1476
Eric Laurent223fd5c2014-11-11 13:43:36 -08001477 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001478 *_aidl_return = false;
1479 return Status::ok();
Eric Laurentdea15412014-10-28 15:46:45 -07001480 }
Eric Laurentdce54a12014-03-10 12:19:46 -07001481 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001482 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001483 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001484 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001485 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001486 *_aidl_return = mAudioPolicyManager->isStreamActive(stream, inPastMs);
1487 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001488}
1489
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001490Status AudioPolicyService::isStreamActiveRemotely(AudioStreamType streamAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001491 int32_t inPastMsAidl,
1492 bool* _aidl_return) {
1493 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1494 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1495 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1496
Eric Laurent223fd5c2014-11-11 13:43:36 -08001497 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001498 *_aidl_return = false;
1499 return Status::ok();
Eric Laurentdea15412014-10-28 15:46:45 -07001500 }
Eric Laurentdce54a12014-03-10 12:19:46 -07001501 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001502 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001503 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001504 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001505 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001506 *_aidl_return = mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
1507 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001508}
1509
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001510Status AudioPolicyService::isSourceActive(AudioSource sourceAidl, bool* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001511 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001512 aidl2legacy_AudioSource_audio_source_t(sourceAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -07001513 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001514 return binderStatusFromStatusT(NO_INIT);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001515 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001516 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001517 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001518 *_aidl_return = mAudioPolicyManager->isSourceActive(source);
1519 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001520}
1521
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001522status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
Eric Laurent2d388ec2014-03-07 13:25:54 -08001523{
Eric Laurentdce54a12014-03-10 12:19:46 -07001524 if (mAudioPolicyManager == NULL) {
Eric Laurent2d388ec2014-03-07 13:25:54 -08001525 return NO_INIT;
1526 }
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001527 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001528 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001529 audioPolicyEffects = mAudioPolicyEffects;
1530 }
1531 if (audioPolicyEffects == 0) {
Eric Laurent8b1e80b2014-10-07 09:08:47 -07001532 return NO_INIT;
1533 }
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001534
1535 return OK;
1536}
1537
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001538Status AudioPolicyService::queryDefaultPreProcessing(
1539 int32_t audioSessionAidl,
Mikhail Naganov0078ee52021-09-30 23:06:20 +00001540 Int* countAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001541 std::vector<media::EffectDescriptor>* _aidl_return) {
1542 audio_session_t audioSession = VALUE_OR_RETURN_BINDER_STATUS(
1543 aidl2legacy_int32_t_audio_session_t(audioSessionAidl));
1544 uint32_t count = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(countAidl->value));
1545 if (count > AudioEffect::kMaxPreProcessing) {
1546 count = AudioEffect::kMaxPreProcessing;
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001547 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001548 uint32_t countReq = count;
1549 std::unique_ptr<effect_descriptor_t[]> descriptors(new effect_descriptor_t[count]);
1550
1551 sp<AudioPolicyEffects> audioPolicyEffects;
1552 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1553 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->queryDefaultInputEffects(
1554 (audio_session_t) audioSession, descriptors.get(), &count)));
1555 countReq = std::min(count, countReq);
1556 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1557 convertRange(descriptors.get(), descriptors.get() + countReq,
1558 std::back_inserter(*_aidl_return),
1559 legacy2aidl_effect_descriptor_t_EffectDescriptor)));
1560 countAidl->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(count));
1561 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001562}
1563
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001564Status AudioPolicyService::addSourceDefaultEffect(const AudioUuid& typeAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001565 const std::string& opPackageNameAidl,
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001566 const AudioUuid& uuidAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001567 int32_t priority,
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001568 AudioSource sourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001569 int32_t* _aidl_return) {
1570 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1571 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1572 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1573 aidl2legacy_string_view_String16(opPackageNameAidl));
1574 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1575 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1576 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001577 aidl2legacy_AudioSource_audio_source_t(sourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001578 audio_unique_id_t id;
1579
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001580 sp<AudioPolicyEffects>audioPolicyEffects;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001581 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
Atneya Nair09859fe2024-07-15 16:38:02 -07001582 if (!(audioserver_permissions() ?
1583 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1584 : modifyDefaultAudioEffectsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001585 return binderStatusFromStatusT(PERMISSION_DENIED);
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001586 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001587 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addSourceDefaultEffect(
1588 &type, opPackageName, &uuid, priority, source, &id)));
1589 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1590 return Status::ok();
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001591}
1592
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001593Status AudioPolicyService::addStreamDefaultEffect(const AudioUuid& typeAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001594 const std::string& opPackageNameAidl,
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001595 const AudioUuid& uuidAidl,
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001596 int32_t priority, AudioUsage usageAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001597 int32_t* _aidl_return) {
1598 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1599 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1600 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1601 aidl2legacy_string_view_String16(opPackageNameAidl));
1602 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1603 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1604 audio_usage_t usage = VALUE_OR_RETURN_BINDER_STATUS(
1605 aidl2legacy_AudioUsage_audio_usage_t(usageAidl));
1606 audio_unique_id_t id;
1607
1608 sp<AudioPolicyEffects> audioPolicyEffects;
1609 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
Atneya Nair09859fe2024-07-15 16:38:02 -07001610 if (!(audioserver_permissions() ?
1611 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1612 : modifyDefaultAudioEffectsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001613 return binderStatusFromStatusT(PERMISSION_DENIED);
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001614 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001615 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addStreamDefaultEffect(
1616 &type, opPackageName, &uuid, priority, usage, &id)));
1617 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1618 return Status::ok();
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001619}
1620
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001621Status AudioPolicyService::removeSourceDefaultEffect(int32_t idAidl)
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001622{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001623 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1624 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001625 sp<AudioPolicyEffects>audioPolicyEffects;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001626 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
Atneya Nair09859fe2024-07-15 16:38:02 -07001627 if (!(audioserver_permissions() ?
1628 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1629 : modifyDefaultAudioEffectsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001630 return binderStatusFromStatusT(PERMISSION_DENIED);
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001631 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001632 return binderStatusFromStatusT(audioPolicyEffects->removeSourceDefaultEffect(id));
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001633}
1634
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001635Status AudioPolicyService::removeStreamDefaultEffect(int32_t idAidl)
Ari Hausman-Cohen24628312018-08-13 15:01:09 -07001636{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001637 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1638 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001639 sp<AudioPolicyEffects>audioPolicyEffects;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001640 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
Atneya Nair09859fe2024-07-15 16:38:02 -07001641 if (!(audioserver_permissions() ?
1642 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1643 : modifyDefaultAudioEffectsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001644 return binderStatusFromStatusT(PERMISSION_DENIED);
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001645 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001646 return binderStatusFromStatusT(audioPolicyEffects->removeStreamDefaultEffect(id));
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -07001647}
1648
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001649Status AudioPolicyService::setSupportedSystemUsages(
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001650 const std::vector<AudioUsage>& systemUsagesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001651 size_t size = systemUsagesAidl.size();
1652 if (size > MAX_ITEMS_PER_LIST) {
1653 size = MAX_ITEMS_PER_LIST;
1654 }
1655 std::vector<audio_usage_t> systemUsages;
1656 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1657 convertRange(systemUsagesAidl.begin(), systemUsagesAidl.begin() + size,
1658 std::back_inserter(systemUsages), aidl2legacy_AudioUsage_audio_usage_t)));
1659
Andy Hung79eacdb2023-11-30 19:34:24 -08001660 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07001661 if (!(audioserver_permissions() ?
1662 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1663 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001664 return binderStatusFromStatusT(PERMISSION_DENIED);
Hayden Gomes524159d2019-12-23 14:41:47 -08001665 }
1666
1667 bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
1668 [](audio_usage_t usage) { return isSystemUsage(usage); });
1669 if (!areAllSystemUsages) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001670 return binderStatusFromStatusT(BAD_VALUE);
Hayden Gomes524159d2019-12-23 14:41:47 -08001671 }
1672
1673 mSupportedSystemUsages = systemUsages;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001674 return Status::ok();
Hayden Gomes524159d2019-12-23 14:41:47 -08001675}
1676
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001677Status AudioPolicyService::setAllowedCapturePolicy(int32_t uidAidl, int32_t capturePolicyAidl) {
1678 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1679 audio_flags_mask_t capturePolicy = VALUE_OR_RETURN_BINDER_STATUS(
1680 aidl2legacy_int32_t_audio_flags_mask_t_mask(capturePolicyAidl));
1681
Andy Hung79eacdb2023-11-30 19:34:24 -08001682 audio_utils::lock_guard _l(mMutex);
Kevin Rocardb99cc752019-03-21 20:52:24 -07001683 if (mAudioPolicyManager == NULL) {
1684 ALOGV("%s() mAudioPolicyManager == NULL", __func__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001685 return binderStatusFromStatusT(NO_INIT);
Kevin Rocardb99cc752019-03-21 20:52:24 -07001686 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001687 return binderStatusFromStatusT(
1688 mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy));
Kevin Rocardb99cc752019-03-21 20:52:24 -07001689}
1690
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001691Status AudioPolicyService::getOffloadSupport(const AudioOffloadInfo& infoAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001692 media::AudioOffloadMode* _aidl_return) {
1693 audio_offload_info_t info = VALUE_OR_RETURN_BINDER_STATUS(
1694 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(infoAidl));
Eric Laurentdce54a12014-03-10 12:19:46 -07001695 if (mAudioPolicyManager == NULL) {
1696 ALOGV("mAudioPolicyManager == NULL");
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001697 return binderStatusFromStatusT(AUDIO_OFFLOAD_NOT_SUPPORTED);
Eric Laurent2d388ec2014-03-07 13:25:54 -08001698 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001699 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07001700 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001701 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_offload_mode_t_AudioOffloadMode(
1702 mAudioPolicyManager->getOffloadSupport(info)));
1703 return Status::ok();
Eric Laurent2d388ec2014-03-07 13:25:54 -08001704}
1705
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001706Status AudioPolicyService::isDirectOutputSupported(
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001707 const AudioConfigBase& configAidl,
Mikhail Naganov1c400902023-05-17 11:48:43 -07001708 const media::audio::common::AudioAttributes& attributesAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001709 bool* _aidl_return) {
1710 audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -07001711 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl, false /*isInput*/));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001712 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07001713 aidl2legacy_AudioAttributes_audio_attributes_t(attributesAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001714 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1715 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1716
Michael Chana94fbb22018-04-24 14:31:19 +10001717 if (mAudioPolicyManager == NULL) {
1718 ALOGV("mAudioPolicyManager == NULL");
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001719 return binderStatusFromStatusT(NO_INIT);
Michael Chana94fbb22018-04-24 14:31:19 +10001720 }
Hayden Gomes524159d2019-12-23 14:41:47 -08001721
Atneya Nair09859fe2024-07-15 16:38:02 -07001722 RETURN_IF_BINDER_ERROR(validateUsage(attributes));
Hayden Gomes524159d2019-12-23 14:41:47 -08001723
Andy Hung79eacdb2023-11-30 19:34:24 -08001724 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001725 *_aidl_return = mAudioPolicyManager->isDirectOutputSupported(config, attributes);
1726 return Status::ok();
Michael Chana94fbb22018-04-24 14:31:19 +10001727}
1728
Atneya Nair23348762024-10-14 14:16:06 -07001729template <typename Port>
1730void anonymizePortBluetoothAddress(Port& port) {
1731 if (port.type != AUDIO_PORT_TYPE_DEVICE) {
1732 return;
1733 }
1734 if (!(audio_is_a2dp_device(port.ext.device.type)
1735 || audio_is_ble_device(port.ext.device.type)
1736 || audio_is_bluetooth_sco_device(port.ext.device.type)
1737 || audio_is_hearing_aid_out_device(port.ext.device.type))) {
1738 return;
1739 }
1740 anonymizeBluetoothAddress(port.ext.device.address);
1741}
Michael Chana94fbb22018-04-24 14:31:19 +10001742
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001743Status AudioPolicyService::listAudioPorts(media::AudioPortRole roleAidl,
Mikhail Naganov0078ee52021-09-30 23:06:20 +00001744 media::AudioPortType typeAidl, Int* count,
Atneya Nair638a6e42022-12-18 16:45:15 -08001745 std::vector<media::AudioPortFw>* portsAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001746 int32_t* _aidl_return) {
1747 audio_port_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
1748 aidl2legacy_AudioPortRole_audio_port_role_t(roleAidl));
1749 audio_port_type_t type = VALUE_OR_RETURN_BINDER_STATUS(
1750 aidl2legacy_AudioPortType_audio_port_type_t(typeAidl));
1751 unsigned int num_ports = VALUE_OR_RETURN_BINDER_STATUS(
1752 convertIntegral<unsigned int>(count->value));
1753 if (num_ports > MAX_ITEMS_PER_LIST) {
1754 num_ports = MAX_ITEMS_PER_LIST;
1755 }
1756 unsigned int numPortsReq = num_ports;
1757 std::unique_ptr<audio_port_v7[]> ports(new audio_port_v7[num_ports]);
1758 unsigned int generation;
1759
Atneya Nair23348762024-10-14 14:16:06 -07001760 const AttributionSourceState attributionSource = getCallingAttributionSource();
Eric Laurent10b71232018-04-13 18:14:44 -07001761 AutoCallerClear acc;
Atneya Nair23348762024-10-14 14:16:06 -07001762 {
1763 audio_utils::lock_guard _l(mMutex);
1764 if (mAudioPolicyManager == NULL) {
1765 return binderStatusFromStatusT(NO_INIT);
1766 }
1767 // AudioPolicyManager->listAudioPorts makes a deep copy of port structs into ports
1768 // so it is safe to access after releasing the mutex
1769 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1770 mAudioPolicyManager->listAudioPorts(
1771 role, type, &num_ports, ports.get(), &generation)));
1772 numPortsReq = std::min(numPortsReq, num_ports);
1773 }
1774
1775 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__))) {
1776 for (size_t i = 0; i < numPortsReq; ++i) {
1777 anonymizePortBluetoothAddress(ports[i]);
1778 }
1779 }
1780
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001781 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1782 convertRange(ports.get(), ports.get() + numPortsReq, std::back_inserter(*portsAidl),
Mikhail Naganov87227252023-01-13 17:38:10 -08001783 legacy2aidl_audio_port_v7_AudioPortFw)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001784 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_ports));
1785 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1786 return Status::ok();
Eric Laurent203b1a12014-04-01 10:34:16 -07001787}
1788
Mikhail Naganov5edc5ed2023-03-23 14:52:15 -07001789Status AudioPolicyService::listDeclaredDevicePorts(media::AudioPortRole role,
1790 std::vector<media::AudioPortFw>* _aidl_return) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001791 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov5edc5ed2023-03-23 14:52:15 -07001792 if (mAudioPolicyManager == NULL) {
1793 return binderStatusFromStatusT(NO_INIT);
1794 }
1795 AutoCallerClear acc;
1796 return binderStatusFromStatusT(mAudioPolicyManager->listDeclaredDevicePorts(
1797 role, _aidl_return));
1798}
1799
Mikhail Naganov17031562022-02-23 23:00:27 +00001800Status AudioPolicyService::getAudioPort(int portId,
Atneya Nair638a6e42022-12-18 16:45:15 -08001801 media::AudioPortFw* _aidl_return) {
Mikhail Naganov17031562022-02-23 23:00:27 +00001802 audio_port_v7 port{ .id = portId };
Atneya Nair23348762024-10-14 14:16:06 -07001803
1804 const AttributionSourceState attributionSource = getCallingAttributionSource();
Eric Laurent10b71232018-04-13 18:14:44 -07001805 AutoCallerClear acc;
Atneya Nair23348762024-10-14 14:16:06 -07001806
1807 {
1808 audio_utils::lock_guard _l(mMutex);
1809 if (mAudioPolicyManager == NULL) {
1810 return binderStatusFromStatusT(NO_INIT);
1811 }
1812 // AudioPolicyManager->getAudioPort makes a deep copy of the port struct into port
1813 // so it is safe to access after releasing the mutex
1814 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(mAudioPolicyManager->getAudioPort(&port)));
1815 }
1816
1817 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__))) {
1818 anonymizePortBluetoothAddress(port);
1819 }
1820
Mikhail Naganov87227252023-01-13 17:38:10 -08001821 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_v7_AudioPortFw(port));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001822 return Status::ok();
Eric Laurent203b1a12014-04-01 10:34:16 -07001823}
1824
Atneya Nair3afdbd12022-12-18 16:14:18 -08001825Status AudioPolicyService::createAudioPatch(const media::AudioPatchFw& patchAidl,
1826 int32_t handleAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001827 int32_t* _aidl_return) {
1828 audio_patch patch = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov87227252023-01-13 17:38:10 -08001829 aidl2legacy_AudioPatchFw_audio_patch(patchAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001830 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1831 aidl2legacy_int32_t_audio_port_handle_t(handleAidl));
1832 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPatch(patch)));
1833
Andy Hung79eacdb2023-11-30 19:34:24 -08001834 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07001835 if (!(audioserver_permissions() ?
1836 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1837 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001838 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent5284ed52014-05-29 14:37:38 -07001839 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001840 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001841 return binderStatusFromStatusT(NO_INIT);
Eric Laurent6a94d692014-05-20 11:18:06 -07001842 }
Eric Laurent10b71232018-04-13 18:14:44 -07001843 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001844 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1845 mAudioPolicyManager->createAudioPatch(&patch, &handle,
1846 IPCThreadState::self()->getCallingUid())));
1847 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
1848 return Status::ok();
Eric Laurent203b1a12014-04-01 10:34:16 -07001849}
1850
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001851Status AudioPolicyService::releaseAudioPatch(int32_t handleAidl)
Eric Laurent203b1a12014-04-01 10:34:16 -07001852{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001853 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1854 aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
Andy Hung79eacdb2023-11-30 19:34:24 -08001855 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07001856 if (!(audioserver_permissions() ?
1857 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1858 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001859 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent5284ed52014-05-29 14:37:38 -07001860 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001861 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001862 return binderStatusFromStatusT(NO_INIT);
Eric Laurent6a94d692014-05-20 11:18:06 -07001863 }
Eric Laurent10b71232018-04-13 18:14:44 -07001864 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001865 return binderStatusFromStatusT(
1866 mAudioPolicyManager->releaseAudioPatch(handle,
1867 IPCThreadState::self()->getCallingUid()));
Eric Laurent203b1a12014-04-01 10:34:16 -07001868}
1869
Mikhail Naganov0078ee52021-09-30 23:06:20 +00001870Status AudioPolicyService::listAudioPatches(Int* count,
Atneya Nair3afdbd12022-12-18 16:14:18 -08001871 std::vector<media::AudioPatchFw>* patchesAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001872 int32_t* _aidl_return) {
1873 unsigned int num_patches = VALUE_OR_RETURN_BINDER_STATUS(
1874 convertIntegral<unsigned int>(count->value));
1875 if (num_patches > MAX_ITEMS_PER_LIST) {
1876 num_patches = MAX_ITEMS_PER_LIST;
1877 }
1878 unsigned int numPatchesReq = num_patches;
1879 std::unique_ptr<audio_patch[]> patches(new audio_patch[num_patches]);
1880 unsigned int generation;
1881
Atneya Nair23348762024-10-14 14:16:06 -07001882 const AttributionSourceState attributionSource = getCallingAttributionSource();
Eric Laurent10b71232018-04-13 18:14:44 -07001883 AutoCallerClear acc;
Atneya Nair23348762024-10-14 14:16:06 -07001884
1885 {
1886 audio_utils::lock_guard _l(mMutex);
1887 if (mAudioPolicyManager == NULL) {
1888 return binderStatusFromStatusT(NO_INIT);
1889 }
1890 // AudioPolicyManager->listAudioPatches makes a deep copy of patches structs into patches
1891 // so it is safe to access after releasing the mutex
1892 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1893 mAudioPolicyManager->listAudioPatches(&num_patches, patches.get(), &generation)));
1894 numPatchesReq = std::min(numPatchesReq, num_patches);
1895 }
1896
1897 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__))) {
1898 for (size_t i = 0; i < numPatchesReq; ++i) {
1899 for (size_t j = 0; j < patches[i].num_sources; ++j) {
1900 anonymizePortBluetoothAddress(patches[i].sources[j]);
1901 }
1902 for (size_t j = 0; j < patches[i].num_sinks; ++j) {
1903 anonymizePortBluetoothAddress(patches[i].sinks[j]);
1904 }
1905 }
1906 }
1907
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001908 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1909 convertRange(patches.get(), patches.get() + numPatchesReq,
Mikhail Naganov87227252023-01-13 17:38:10 -08001910 std::back_inserter(*patchesAidl), legacy2aidl_audio_patch_AudioPatchFw)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001911 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_patches));
1912 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1913 return Status::ok();
Eric Laurent203b1a12014-04-01 10:34:16 -07001914}
1915
Atneya Nair7a9594f2022-12-18 17:26:26 -08001916Status AudioPolicyService::setAudioPortConfig(const media::AudioPortConfigFw& configAidl)
Eric Laurent203b1a12014-04-01 10:34:16 -07001917{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001918 audio_port_config config = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov87227252023-01-13 17:38:10 -08001919 aidl2legacy_AudioPortConfigFw_audio_port_config(configAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001920 RETURN_IF_BINDER_ERROR(
1921 binderStatusFromStatusT(AudioValidator::validateAudioPortConfig(config)));
1922
Andy Hung79eacdb2023-11-30 19:34:24 -08001923 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07001924 if (!(audioserver_permissions() ?
1925 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1926 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001927 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurent5284ed52014-05-29 14:37:38 -07001928 }
Eric Laurent6a94d692014-05-20 11:18:06 -07001929 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001930 return binderStatusFromStatusT(NO_INIT);
Eric Laurent6a94d692014-05-20 11:18:06 -07001931 }
Eric Laurent10b71232018-04-13 18:14:44 -07001932 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001933 return binderStatusFromStatusT(mAudioPolicyManager->setAudioPortConfig(&config));
Eric Laurent203b1a12014-04-01 10:34:16 -07001934}
Eric Laurent2d388ec2014-03-07 13:25:54 -08001935
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001936Status AudioPolicyService::acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return)
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001937{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001938 audio_session_t session;
1939 audio_io_handle_t ioHandle;
1940 audio_devices_t device;
1941
1942 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001943 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001944 if (mAudioPolicyManager == NULL) {
1945 return binderStatusFromStatusT(NO_INIT);
1946 }
1947 AutoCallerClear acc;
1948 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1949 mAudioPolicyManager->acquireSoundTriggerSession(&session, &ioHandle, &device)));
1950 }
1951
1952 _aidl_return->session = VALUE_OR_RETURN_BINDER_STATUS(
1953 legacy2aidl_audio_session_t_int32_t(session));
1954 _aidl_return->ioHandle = VALUE_OR_RETURN_BINDER_STATUS(
1955 legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
1956 _aidl_return->device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07001957 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001958 return Status::ok();
1959}
1960
1961Status AudioPolicyService::releaseSoundTriggerSession(int32_t sessionAidl)
1962{
1963 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
1964 aidl2legacy_int32_t_audio_session_t(sessionAidl));
Andy Hung79eacdb2023-11-30 19:34:24 -08001965 audio_utils::lock_guard _l(mMutex);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001966 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001967 return binderStatusFromStatusT(NO_INIT);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001968 }
Eric Laurent10b71232018-04-13 18:14:44 -07001969 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001970 return binderStatusFromStatusT(mAudioPolicyManager->releaseSoundTriggerSession(session));
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001971}
1972
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001973Status AudioPolicyService::registerPolicyMixes(const std::vector<media::AudioMix>& mixesAidl,
1974 bool registration) {
1975 size_t size = mixesAidl.size();
1976 if (size > MAX_MIXES_PER_POLICY) {
1977 size = MAX_MIXES_PER_POLICY;
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001978 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001979 Vector<AudioMix> mixes;
1980 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1981 convertRange(mixesAidl.begin(), mixesAidl.begin() + size, std::back_inserter(mixes),
1982 aidl2legacy_AudioMix)));
Eric Laurentdf3dc7e2014-07-27 18:39:40 -07001983
Andy Hung79eacdb2023-11-30 19:34:24 -08001984 audio_utils::lock_guard _l(mMutex);
Kevin Rocardbe201852019-02-20 22:33:28 -08001985
1986 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
1987 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1988 return !is_mix_loopback_render(mix.mRouteFlags); });
Atneya Nair09859fe2024-07-15 16:38:02 -07001989 if (needModifyAudioRouting && !(audioserver_permissions() ?
1990 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1991 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001992 return binderStatusFromStatusT(PERMISSION_DENIED);
Eric Laurentbaac1832014-12-01 17:52:59 -08001993 }
Kevin Rocardbe201852019-02-20 22:33:28 -08001994
Nadav Bar287d3302020-02-05 14:55:38 +02001995 // If one of the mixes has needCaptureVoiceCommunicationOutput set to true, then we
1996 // need to verify that the caller still has CAPTURE_VOICE_COMMUNICATION_OUTPUT
Nadav Bardbf0a2e2020-01-16 23:09:25 +02001997 bool needCaptureVoiceCommunicationOutput =
1998 std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
Nadav Bar287d3302020-02-05 14:55:38 +02001999 return mix.mVoiceCommunicationCaptureAllowed; });
Nadav Bardbf0a2e2020-01-16 23:09:25 +02002000
Kevin Rocard36b17552019-03-07 18:48:07 -08002001 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
Eric Laurent5f9a6452020-12-22 20:10:10 +01002002 return mix.mAllowPrivilegedMediaPlaybackCapture; });
Nadav Bardbf0a2e2020-01-16 23:09:25 +02002003
Svet Ganov3e5f14f2021-05-13 22:51:08 +00002004 const AttributionSourceState attributionSource = getCallingAttributionSource();
Nadav Bardbf0a2e2020-01-16 23:09:25 +02002005
Philip P. Moltmannbda45752020-07-17 16:41:18 -07002006
Atneya Nair09859fe2024-07-15 16:38:02 -07002007 if (needCaptureMediaOutput && !(audioserver_permissions() ?
2008 CHECK_PERM(CAPTURE_MEDIA_OUTPUT, attributionSource.uid)
2009 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002010 return binderStatusFromStatusT(PERMISSION_DENIED);
Kevin Rocard36b17552019-03-07 18:48:07 -08002011 }
2012
Nadav Bardbf0a2e2020-01-16 23:09:25 +02002013 if (needCaptureVoiceCommunicationOutput &&
Atneya Nair09859fe2024-07-15 16:38:02 -07002014 !(audioserver_permissions() ?
2015 CHECK_PERM(CAPTURE_VOICE_COMMUNICATION_OUTPUT, attributionSource.uid)
2016 : captureVoiceCommunicationOutputAllowed(attributionSource))) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002017 return binderStatusFromStatusT(PERMISSION_DENIED);
Nadav Bardbf0a2e2020-01-16 23:09:25 +02002018 }
2019
Eric Laurentbaac1832014-12-01 17:52:59 -08002020 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002021 return binderStatusFromStatusT(NO_INIT);
Eric Laurentbaac1832014-12-01 17:52:59 -08002022 }
Eric Laurent10b71232018-04-13 18:14:44 -07002023 AutoCallerClear acc;
Eric Laurentbaac1832014-12-01 17:52:59 -08002024 if (registration) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002025 return binderStatusFromStatusT(mAudioPolicyManager->registerPolicyMixes(mixes));
Eric Laurentbaac1832014-12-01 17:52:59 -08002026 } else {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002027 return binderStatusFromStatusT(mAudioPolicyManager->unregisterPolicyMixes(mixes));
Eric Laurentbaac1832014-12-01 17:52:59 -08002028 }
2029}
2030
Marvin Raminbdefaf02023-11-01 09:10:32 +01002031Status
2032AudioPolicyService::getRegisteredPolicyMixes(std::vector<::android::media::AudioMix>* mixesAidl) {
2033 if (mAudioPolicyManager == nullptr) {
2034 return binderStatusFromStatusT(NO_INIT);
2035 }
2036
2037 std::vector<AudioMix> mixes;
2038 int status = mAudioPolicyManager->getRegisteredPolicyMixes(mixes);
2039
2040 for (const auto& mix : mixes) {
2041 media::AudioMix aidlMix = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_AudioMix(mix));
2042 mixesAidl->push_back(aidlMix);
2043 }
2044
2045 return binderStatusFromStatusT(status);
2046}
2047
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02002048Status AudioPolicyService::updatePolicyMixes(
2049 const ::std::vector<::android::media::AudioMixUpdate>& updates) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002050 audio_utils::lock_guard _l(mMutex);
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02002051 for (const auto& update : updates) {
2052 AudioMix mix = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_AudioMix(update.audioMix));
2053 std::vector<AudioMixMatchCriterion> newCriteria =
2054 VALUE_OR_RETURN_BINDER_STATUS(convertContainer<std::vector<AudioMixMatchCriterion>>(
2055 update.newCriteria, aidl2legacy_AudioMixMatchCriterion));
2056 int status;
2057 if((status = mAudioPolicyManager->updatePolicyMix(mix, newCriteria)) != NO_ERROR) {
2058 return binderStatusFromStatusT(status);
2059 }
2060 }
2061 return binderStatusFromStatusT(NO_ERROR);
2062}
2063
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002064Status AudioPolicyService::setUidDeviceAffinities(
2065 int32_t uidAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002066 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002067 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2068 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2069 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2070 aidl2legacy_AudioDeviceTypeAddress));
2071
Andy Hung79eacdb2023-11-30 19:34:24 -08002072 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07002073 if (!(audioserver_permissions() ?
2074 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2075 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002076 return binderStatusFromStatusT(PERMISSION_DENIED);
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002077 }
2078 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002079 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002080 }
2081 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002082 return binderStatusFromStatusT(mAudioPolicyManager->setUidDeviceAffinities(uid, devices));
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002083}
2084
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002085Status AudioPolicyService::removeUidDeviceAffinities(int32_t uidAidl) {
2086 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2087
Andy Hung79eacdb2023-11-30 19:34:24 -08002088 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07002089 if (!(audioserver_permissions() ?
2090 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2091 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002092 return binderStatusFromStatusT(PERMISSION_DENIED);
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002093 }
2094 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002095 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002096 }
2097 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002098 return binderStatusFromStatusT(mAudioPolicyManager->removeUidDeviceAffinities(uid));
Jean-Michel Trivibda70da2018-12-19 07:30:15 -08002099}
2100
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002101Status AudioPolicyService::setUserIdDeviceAffinities(
2102 int32_t userIdAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002103 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002104 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
2105 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2106 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2107 aidl2legacy_AudioDeviceTypeAddress));
2108
Andy Hung79eacdb2023-11-30 19:34:24 -08002109 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07002110 if (!(audioserver_permissions() ?
2111 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2112 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002113 return binderStatusFromStatusT(PERMISSION_DENIED);
Oscar Azucena90e77632019-11-27 17:12:28 -08002114 }
2115 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002116 return binderStatusFromStatusT(NO_INIT);
Oscar Azucena90e77632019-11-27 17:12:28 -08002117 }
2118 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002119 return binderStatusFromStatusT(mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices));
Oscar Azucena90e77632019-11-27 17:12:28 -08002120}
2121
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002122Status AudioPolicyService::removeUserIdDeviceAffinities(int32_t userIdAidl) {
2123 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
2124
Andy Hung79eacdb2023-11-30 19:34:24 -08002125 audio_utils::lock_guard _l(mMutex);
Atneya Nair09859fe2024-07-15 16:38:02 -07002126 if (!(audioserver_permissions() ?
2127 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2128 : modifyAudioRoutingAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002129 return binderStatusFromStatusT(PERMISSION_DENIED);
Oscar Azucena90e77632019-11-27 17:12:28 -08002130 }
2131 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002132 return binderStatusFromStatusT(NO_INIT);
Oscar Azucena90e77632019-11-27 17:12:28 -08002133 }
2134 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002135 return binderStatusFromStatusT(mAudioPolicyManager->removeUserIdDeviceAffinities(userId));
Oscar Azucena90e77632019-11-27 17:12:28 -08002136}
2137
Atneya Nair7a9594f2022-12-18 17:26:26 -08002138Status AudioPolicyService::startAudioSource(const media::AudioPortConfigFw& sourceAidl,
Mikhail Naganov1c400902023-05-17 11:48:43 -07002139 const media::audio::common::AudioAttributes& attributesAidl,
2140 int32_t* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002141 audio_port_config source = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov87227252023-01-13 17:38:10 -08002142 aidl2legacy_AudioPortConfigFw_audio_port_config(sourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002143 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002144 aidl2legacy_AudioAttributes_audio_attributes_t(attributesAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002145 audio_port_handle_t portId;
2146 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2147 AudioValidator::validateAudioPortConfig(source)));
2148 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2149 AudioValidator::validateAudioAttributes(attributes, "68953950")));
2150
Andy Hung79eacdb2023-11-30 19:34:24 -08002151 audio_utils::lock_guard _l(mMutex);
Eric Laurent554a2772015-04-10 11:29:24 -07002152 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002153 return binderStatusFromStatusT(NO_INIT);
Eric Laurent554a2772015-04-10 11:29:24 -07002154 }
Hayden Gomes524159d2019-12-23 14:41:47 -08002155
Atneya Nair09859fe2024-07-15 16:38:02 -07002156 RETURN_IF_BINDER_ERROR(validateUsage(attributes));
Hayden Gomes524159d2019-12-23 14:41:47 -08002157
Hongwei Wang5cd1f1d2019-03-26 15:21:11 -07002158 // startAudioSource should be created as the calling uid
2159 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
Eric Laurent10b71232018-04-13 18:14:44 -07002160 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002161 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2162 mAudioPolicyManager->startAudioSource(&source, &attributes, &portId, callingUid)));
2163 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2164 return Status::ok();
Eric Laurent554a2772015-04-10 11:29:24 -07002165}
2166
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002167Status AudioPolicyService::stopAudioSource(int32_t portIdAidl)
Eric Laurent554a2772015-04-10 11:29:24 -07002168{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002169 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2170 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2171
Andy Hung79eacdb2023-11-30 19:34:24 -08002172 audio_utils::lock_guard _l(mMutex);
Eric Laurent554a2772015-04-10 11:29:24 -07002173 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002174 return binderStatusFromStatusT(NO_INIT);
Eric Laurent554a2772015-04-10 11:29:24 -07002175 }
Eric Laurent10b71232018-04-13 18:14:44 -07002176 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002177 return binderStatusFromStatusT(mAudioPolicyManager->stopAudioSource(portId));
Eric Laurent554a2772015-04-10 11:29:24 -07002178}
2179
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002180Status AudioPolicyService::setMasterMono(bool mono)
Andy Hung2ddee192015-12-18 17:34:44 -08002181{
2182 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002183 return binderStatusFromStatusT(NO_INIT);
Andy Hung2ddee192015-12-18 17:34:44 -08002184 }
Atneya Nair09859fe2024-07-15 16:38:02 -07002185 if (!(audioserver_permissions() ?
2186 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
2187 : settingsAllowed())) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002188 return binderStatusFromStatusT(PERMISSION_DENIED);
Andy Hung2ddee192015-12-18 17:34:44 -08002189 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002190 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07002191 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002192 return binderStatusFromStatusT(mAudioPolicyManager->setMasterMono(mono));
Andy Hung2ddee192015-12-18 17:34:44 -08002193}
2194
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002195Status AudioPolicyService::getMasterMono(bool* _aidl_return)
Andy Hung2ddee192015-12-18 17:34:44 -08002196{
2197 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002198 return binderStatusFromStatusT(NO_INIT);
Andy Hung2ddee192015-12-18 17:34:44 -08002199 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002200 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07002201 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002202 return binderStatusFromStatusT(mAudioPolicyManager->getMasterMono(_aidl_return));
Andy Hung2ddee192015-12-18 17:34:44 -08002203}
2204
Eric Laurentac9cef52017-06-09 15:46:26 -07002205
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07002206Status AudioPolicyService::getStreamVolumeDB(
Mikhail Naganovdbf03642021-08-25 18:15:32 -07002207 AudioStreamType streamAidl, int32_t indexAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002208 const AudioDeviceDescription& deviceAidl, float* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002209 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
2210 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
2211 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
2212 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov21a32ec2021-07-08 14:40:12 -07002213 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002214
Eric Laurentac9cef52017-06-09 15:46:26 -07002215 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002216 return binderStatusFromStatusT(NO_INIT);
Eric Laurentac9cef52017-06-09 15:46:26 -07002217 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002218 audio_utils::lock_guard _l(mMutex);
Eric Laurent10b71232018-04-13 18:14:44 -07002219 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002220 *_aidl_return = mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
2221 return Status::ok();
Eric Laurentac9cef52017-06-09 15:46:26 -07002222}
2223
Mikhail Naganov0078ee52021-09-30 23:06:20 +00002224Status AudioPolicyService::getSurroundFormats(Int* count,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -07002225 std::vector<AudioFormatDescription>* formats,
Kriti Dang877b27e2021-02-02 12:10:40 +01002226 std::vector<bool>* formatsEnabled) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002227 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
2228 convertIntegral<unsigned int>(count->value));
2229 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
2230 numSurroundFormats = MAX_ITEMS_PER_LIST;
2231 }
2232 unsigned int numSurroundFormatsReq = numSurroundFormats;
2233 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
Kriti Dang877b27e2021-02-02 12:10:40 +01002234 std::unique_ptr<bool[]>surroundFormatsEnabled(new bool[numSurroundFormats]);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002235
jiabin81772902018-04-02 17:52:27 -07002236 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002237 return binderStatusFromStatusT(NO_INIT);
jiabin81772902018-04-02 17:52:27 -07002238 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002239 audio_utils::lock_guard _l(mMutex);
jiabin81772902018-04-02 17:52:27 -07002240 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002241 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2242 mAudioPolicyManager->getSurroundFormats(&numSurroundFormats, surroundFormats.get(),
Kriti Dang6537def2021-03-02 13:46:59 +01002243 surroundFormatsEnabled.get())));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002244 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
2245 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2246 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -07002247 std::back_inserter(*formats),
2248 legacy2aidl_audio_format_t_AudioFormatDescription)));
Kriti Dang877b27e2021-02-02 12:10:40 +01002249 formatsEnabled->insert(
2250 formatsEnabled->begin(),
2251 surroundFormatsEnabled.get(),
2252 surroundFormatsEnabled.get() + numSurroundFormatsReq);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002253 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
2254 return Status::ok();
jiabin81772902018-04-02 17:52:27 -07002255}
2256
Kriti Dang6537def2021-03-02 13:46:59 +01002257Status AudioPolicyService::getReportedSurroundFormats(
Mikhail Naganov0078ee52021-09-30 23:06:20 +00002258 Int* count, std::vector<AudioFormatDescription>* formats) {
Kriti Dang6537def2021-03-02 13:46:59 +01002259 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
2260 convertIntegral<unsigned int>(count->value));
2261 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
2262 numSurroundFormats = MAX_ITEMS_PER_LIST;
2263 }
2264 unsigned int numSurroundFormatsReq = numSurroundFormats;
2265 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
2266
2267 if (mAudioPolicyManager == NULL) {
2268 return binderStatusFromStatusT(NO_INIT);
2269 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002270 audio_utils::lock_guard _l(mMutex);
Kriti Dang6537def2021-03-02 13:46:59 +01002271 AutoCallerClear acc;
2272 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2273 mAudioPolicyManager->getReportedSurroundFormats(
2274 &numSurroundFormats, surroundFormats.get())));
2275 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
2276 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2277 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -07002278 std::back_inserter(*formats),
2279 legacy2aidl_audio_format_t_AudioFormatDescription)));
Kriti Dang6537def2021-03-02 13:46:59 +01002280 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
2281 return Status::ok();
2282}
2283
Pattydd807582021-11-04 21:01:03 +08002284Status AudioPolicyService::getHwOffloadFormatsSupportedForBluetoothMedia(
2285 const AudioDeviceDescription& deviceAidl,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -07002286 std::vector<AudioFormatDescription>* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002287 std::vector<audio_format_t> formats;
2288
Arun Mirpuri11029ad2018-12-19 20:45:19 -08002289 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002290 return binderStatusFromStatusT(NO_INIT);
Arun Mirpuri11029ad2018-12-19 20:45:19 -08002291 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002292 audio_utils::lock_guard _l(mMutex);
Arun Mirpuri11029ad2018-12-19 20:45:19 -08002293 AutoCallerClear acc;
Pattydd807582021-11-04 21:01:03 +08002294 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
2295 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002296 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
Pattydd807582021-11-04 21:01:03 +08002297 mAudioPolicyManager->getHwOffloadFormatsSupportedForBluetoothMedia(device, &formats)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002298 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov57bd06f2021-08-10 16:41:54 -07002299 convertContainer<std::vector<AudioFormatDescription>>(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002300 formats,
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -07002301 legacy2aidl_audio_format_t_AudioFormatDescription));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002302 return Status::ok();
Arun Mirpuri11029ad2018-12-19 20:45:19 -08002303}
2304
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002305Status AudioPolicyService::setSurroundFormatEnabled(
Mikhail Naganov57bd06f2021-08-10 16:41:54 -07002306 const AudioFormatDescription& audioFormatAidl, bool enabled) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002307 audio_format_t audioFormat = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -07002308 aidl2legacy_AudioFormatDescription_audio_format_t(audioFormatAidl));
jiabin81772902018-04-02 17:52:27 -07002309 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002310 return binderStatusFromStatusT(NO_INIT);
jiabin81772902018-04-02 17:52:27 -07002311 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002312 audio_utils::lock_guard _l(mMutex);
jiabin81772902018-04-02 17:52:27 -07002313 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002314 return binderStatusFromStatusT(
2315 mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));
jiabin81772902018-04-02 17:52:27 -07002316}
Eric Laurentac9cef52017-06-09 15:46:26 -07002317
Oscar Azucena829d90d2022-01-28 17:17:56 -08002318Status convertInt32VectorToUidVectorWithLimit(
2319 const std::vector<int32_t>& uidsAidl, std::vector<uid_t>& uids) {
2320 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2321 convertRangeWithLimit(uidsAidl.begin(),
2322 uidsAidl.end(),
2323 std::back_inserter(uids),
2324 aidl2legacy_int32_t_uid_t,
2325 MAX_ITEMS_PER_LIST)));
2326
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002327 return Status::ok();
Eric Laurentb78763e2018-10-17 10:08:02 -07002328}
2329
Oscar Azucena829d90d2022-01-28 17:17:56 -08002330Status AudioPolicyService::setAssistantServicesUids(const std::vector<int32_t>& uidsAidl)
Ahaan Ugalef51ce002021-08-04 16:34:20 -07002331{
Oscar Azucena829d90d2022-01-28 17:17:56 -08002332 std::vector<uid_t> uids;
2333 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));
2334
Andy Hung79eacdb2023-11-30 19:34:24 -08002335 audio_utils::lock_guard _l(mMutex);
Oscar Azucena829d90d2022-01-28 17:17:56 -08002336 mUidPolicy->setAssistantUids(uids);
Ahaan Ugalef51ce002021-08-04 16:34:20 -07002337 return Status::ok();
2338}
2339
Oscar Azucenac2cdda32022-01-31 19:10:39 -08002340Status AudioPolicyService::setActiveAssistantServicesUids(
2341 const std::vector<int32_t>& activeUidsAidl) {
2342 std::vector<uid_t> activeUids;
2343 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(activeUidsAidl, activeUids));
2344
Andy Hung79eacdb2023-11-30 19:34:24 -08002345 audio_utils::lock_guard _l(mMutex);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08002346 mUidPolicy->setActiveAssistantUids(activeUids);
2347 return Status::ok();
2348}
2349
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002350Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)
Eric Laurentb78763e2018-10-17 10:08:02 -07002351{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002352 std::vector<uid_t> uids;
Oscar Azucena829d90d2022-01-28 17:17:56 -08002353 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));
2354
Andy Hung79eacdb2023-11-30 19:34:24 -08002355 audio_utils::lock_guard _l(mMutex);
Eric Laurentb78763e2018-10-17 10:08:02 -07002356 mUidPolicy->setA11yUids(uids);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002357 return Status::ok();
Eric Laurentb78763e2018-10-17 10:08:02 -07002358}
2359
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002360Status AudioPolicyService::setCurrentImeUid(int32_t uidAidl)
Kohsuke Yatoha623a132020-03-24 20:10:26 -07002361{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002362 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
Andy Hung79eacdb2023-11-30 19:34:24 -08002363 audio_utils::lock_guard _l(mMutex);
Kohsuke Yatoha623a132020-03-24 20:10:26 -07002364 mUidPolicy->setCurrentImeUid(uid);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002365 return Status::ok();
Kohsuke Yatoha623a132020-03-24 20:10:26 -07002366}
2367
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002368Status AudioPolicyService::isHapticPlaybackSupported(bool* _aidl_return)
jiabin6012f912018-11-02 17:06:30 -07002369{
2370 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002371 return binderStatusFromStatusT(NO_INIT);
jiabin6012f912018-11-02 17:06:30 -07002372 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002373 audio_utils::lock_guard _l(mMutex);
jiabin6012f912018-11-02 17:06:30 -07002374 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002375 *_aidl_return = mAudioPolicyManager->isHapticPlaybackSupported();
2376 return Status::ok();
jiabin6012f912018-11-02 17:06:30 -07002377}
2378
Carter Hsu325a8eb2022-01-19 19:56:51 +08002379Status AudioPolicyService::isUltrasoundSupported(bool* _aidl_return)
2380{
2381 if (mAudioPolicyManager == NULL) {
2382 return binderStatusFromStatusT(NO_INIT);
2383 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002384 audio_utils::lock_guard _l(mMutex);
Carter Hsu325a8eb2022-01-19 19:56:51 +08002385 AutoCallerClear acc;
2386 *_aidl_return = mAudioPolicyManager->isUltrasoundSupported();
2387 return Status::ok();
2388}
2389
Atneya Nair698f5ef2022-12-15 16:15:09 -08002390Status AudioPolicyService::isHotwordStreamSupported(bool lookbackAudio, bool* _aidl_return)
2391{
2392 if (mAudioPolicyManager == nullptr) {
2393 return binderStatusFromStatusT(NO_INIT);
2394 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002395 audio_utils::lock_guard _l(mMutex);
Atneya Nair698f5ef2022-12-15 16:15:09 -08002396 AutoCallerClear acc;
2397 *_aidl_return = mAudioPolicyManager->isHotwordStreamSupported(lookbackAudio);
2398 return Status::ok();
2399}
2400
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002401Status AudioPolicyService::listAudioProductStrategies(
2402 std::vector<media::AudioProductStrategy>* _aidl_return) {
2403 AudioProductStrategyVector strategies;
2404
François Gaffied0ba9ed2018-11-05 11:50:42 +01002405 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002406 return binderStatusFromStatusT(NO_INIT);
François Gaffied0ba9ed2018-11-05 11:50:42 +01002407 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002408 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002409 RETURN_IF_BINDER_ERROR(
2410 binderStatusFromStatusT(mAudioPolicyManager->listAudioProductStrategies(strategies)));
2411 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2412 convertContainer<std::vector<media::AudioProductStrategy>>(
2413 strategies,
2414 legacy2aidl_AudioProductStrategy));
2415 return Status::ok();
François Gaffied0ba9ed2018-11-05 11:50:42 +01002416}
2417
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002418Status AudioPolicyService::getProductStrategyFromAudioAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002419 const media::audio::common::AudioAttributes& aaAidl,
François Gaffie1e2b56f2022-04-01 14:34:29 +02002420 bool fallbackOnDefault, int32_t* _aidl_return) {
2421 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002422 aidl2legacy_AudioAttributes_audio_attributes_t(aaAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002423 product_strategy_t productStrategy;
2424
François Gaffied0ba9ed2018-11-05 11:50:42 +01002425 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002426 return binderStatusFromStatusT(NO_INIT);
François Gaffied0ba9ed2018-11-05 11:50:42 +01002427 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002428 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002429 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
Francois Gaffie11b65922020-09-24 16:59:08 +02002430 mAudioPolicyManager->getProductStrategyFromAudioAttributes(
2431 aa, productStrategy, fallbackOnDefault)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002432 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2433 legacy2aidl_product_strategy_t_int32_t(productStrategy));
2434 return Status::ok();
François Gaffie4b2018b2018-11-07 11:18:59 +01002435}
2436
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002437Status AudioPolicyService::listAudioVolumeGroups(std::vector<media::AudioVolumeGroup>* _aidl_return)
François Gaffie4b2018b2018-11-07 11:18:59 +01002438{
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002439 AudioVolumeGroupVector groups;
François Gaffie4b2018b2018-11-07 11:18:59 +01002440 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002441 return binderStatusFromStatusT(NO_INIT);
François Gaffie4b2018b2018-11-07 11:18:59 +01002442 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002443 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002444 RETURN_IF_BINDER_ERROR(
2445 binderStatusFromStatusT(mAudioPolicyManager->listAudioVolumeGroups(groups)));
2446 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2447 convertContainer<std::vector<media::AudioVolumeGroup>>(groups,
2448 legacy2aidl_AudioVolumeGroup));
2449 return Status::ok();
François Gaffie4b2018b2018-11-07 11:18:59 +01002450}
2451
Francois Gaffie11b65922020-09-24 16:59:08 +02002452Status AudioPolicyService::getVolumeGroupFromAudioAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002453 const media::audio::common::AudioAttributes& aaAidl,
François Gaffie1e2b56f2022-04-01 14:34:29 +02002454 bool fallbackOnDefault, int32_t* _aidl_return) {
2455 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002456 aidl2legacy_AudioAttributes_audio_attributes_t(aaAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002457 volume_group_t volumeGroup;
2458
François Gaffie4b2018b2018-11-07 11:18:59 +01002459 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002460 return binderStatusFromStatusT(NO_INIT);
François Gaffie4b2018b2018-11-07 11:18:59 +01002461 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002462 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002463 RETURN_IF_BINDER_ERROR(
2464 binderStatusFromStatusT(
Francois Gaffie11b65922020-09-24 16:59:08 +02002465 mAudioPolicyManager->getVolumeGroupFromAudioAttributes(
2466 aa, volumeGroup, fallbackOnDefault)));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002467 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_volume_group_t_int32_t(volumeGroup));
2468 return Status::ok();
François Gaffied0ba9ed2018-11-05 11:50:42 +01002469}
Eric Laurent6ede98f2019-06-11 14:50:30 -07002470
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002471Status AudioPolicyService::setRttEnabled(bool enabled)
Eric Laurent6ede98f2019-06-11 14:50:30 -07002472{
Andy Hung79eacdb2023-11-30 19:34:24 -08002473 audio_utils::lock_guard _l(mMutex);
Eric Laurent6ede98f2019-06-11 14:50:30 -07002474 mUidPolicy->setRttEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002475 return Status::ok();
Eric Laurent6ede98f2019-06-11 14:50:30 -07002476}
2477
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002478Status AudioPolicyService::isCallScreenModeSupported(bool* _aidl_return)
Eric Laurent8340e672019-11-06 11:01:08 -08002479{
2480 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002481 return binderStatusFromStatusT(NO_INIT);
Eric Laurent8340e672019-11-06 11:01:08 -08002482 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002483 audio_utils::lock_guard _l(mMutex);
Eric Laurent8340e672019-11-06 11:01:08 -08002484 AutoCallerClear acc;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002485 *_aidl_return = mAudioPolicyManager->isCallScreenModeSupported();
2486 return Status::ok();
Eric Laurent8340e672019-11-06 11:01:08 -08002487}
2488
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002489Status AudioPolicyService::setDevicesRoleForStrategy(
2490 int32_t strategyAidl,
2491 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002492 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002493 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2494 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2495 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2496 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2497 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2498 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2499 aidl2legacy_AudioDeviceTypeAddress));
2500
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002501 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002502 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002503 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002504 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +02002505 status_t status = mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices);
2506 if (status == NO_ERROR) {
2507 onCheckSpatializer_l();
2508 }
2509 return binderStatusFromStatusT(status);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002510}
2511
Paul Wang5d7cdb52022-11-22 09:45:06 +00002512Status AudioPolicyService::removeDevicesRoleForStrategy(
2513 int32_t strategyAidl,
2514 media::DeviceRole roleAidl,
2515 const std::vector<AudioDevice>& devicesAidl) {
2516 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2517 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2518 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2519 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2520 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2521 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2522 aidl2legacy_AudioDeviceTypeAddress));
2523
2524 if (mAudioPolicyManager == NULL) {
2525 return binderStatusFromStatusT(NO_INIT);
2526 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002527 audio_utils::lock_guard _l(mMutex);
Paul Wang5d7cdb52022-11-22 09:45:06 +00002528 status_t status = mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role, devices);
2529 if (status == NO_ERROR) {
2530 onCheckSpatializer_l();
2531 }
2532 return binderStatusFromStatusT(status);
2533}
2534
2535Status AudioPolicyService::clearDevicesRoleForStrategy(int32_t strategyAidl,
2536 media::DeviceRole roleAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002537 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2538 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2539 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2540 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2541 if (mAudioPolicyManager == NULL) {
2542 return binderStatusFromStatusT(NO_INIT);
2543 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002544 audio_utils::lock_guard _l(mMutex);
Paul Wang5d7cdb52022-11-22 09:45:06 +00002545 status_t status = mAudioPolicyManager->clearDevicesRoleForStrategy(strategy, role);
Eric Laurent39095982021-08-24 18:29:27 +02002546 if (status == NO_ERROR) {
2547 onCheckSpatializer_l();
2548 }
2549 return binderStatusFromStatusT(status);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002550}
2551
2552Status AudioPolicyService::getDevicesForRoleAndStrategy(
2553 int32_t strategyAidl,
2554 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002555 std::vector<AudioDevice>* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002556 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2557 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2558 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2559 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2560 AudioDeviceTypeAddrVector devices;
2561
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002562 if (mAudioPolicyManager == NULL) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002563 return binderStatusFromStatusT(NO_INIT);
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002564 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002565 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002566 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2567 mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices)));
2568 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002569 convertContainer<std::vector<AudioDevice>>(devices,
2570 legacy2aidl_AudioDeviceTypeAddress));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002571 return Status::ok();
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002572}
2573
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002574Status AudioPolicyService::registerSoundTriggerCaptureStateListener(
2575 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) {
2576 *_aidl_return = mCaptureStateNotifier.RegisterListener(listener);
2577 return Status::ok();
Jean-Michel Trivi30857152019-11-01 11:04:15 -07002578}
2579
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002580Status AudioPolicyService::setDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002581 AudioSource audioSourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002582 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002583 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002584 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002585 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002586 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2587 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2588 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2589 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2590 aidl2legacy_AudioDeviceTypeAddress));
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -07002591
Jiabin Huang3b98d322020-09-03 17:54:16 +00002592 if (mAudioPolicyManager == nullptr) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002593 return binderStatusFromStatusT(NO_INIT);
Jiabin Huang3b98d322020-09-03 17:54:16 +00002594 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002595 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002596 return binderStatusFromStatusT(
2597 mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices));
Jiabin Huang3b98d322020-09-03 17:54:16 +00002598}
2599
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002600Status AudioPolicyService::addDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002601 AudioSource audioSourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002602 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002603 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002604 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002605 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002606 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2607 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2608 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2609 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2610 aidl2legacy_AudioDeviceTypeAddress));
2611
Jiabin Huang3b98d322020-09-03 17:54:16 +00002612 if (mAudioPolicyManager == nullptr) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002613 return binderStatusFromStatusT(NO_INIT);
Jiabin Huang3b98d322020-09-03 17:54:16 +00002614 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002615 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002616 return binderStatusFromStatusT(
2617 mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices));
Jiabin Huang3b98d322020-09-03 17:54:16 +00002618}
2619
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002620Status AudioPolicyService::removeDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002621 AudioSource audioSourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002622 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002623 const std::vector<AudioDevice>& devicesAidl) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002624 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002625 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002626 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2627 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2628 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2629 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2630 aidl2legacy_AudioDeviceTypeAddress));
2631
2632 if (mAudioPolicyManager == nullptr) {
2633 return binderStatusFromStatusT(NO_INIT);
Jiabin Huang3b98d322020-09-03 17:54:16 +00002634 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002635 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002636 return binderStatusFromStatusT(
2637 mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
Jiabin Huang3b98d322020-09-03 17:54:16 +00002638}
2639
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002640Status AudioPolicyService::clearDevicesRoleForCapturePreset(AudioSource audioSourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002641 media::DeviceRole roleAidl) {
2642 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002643 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002644 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2645 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2646
Jiabin Huang3b98d322020-09-03 17:54:16 +00002647 if (mAudioPolicyManager == nullptr) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002648 return binderStatusFromStatusT(NO_INIT);
Jiabin Huang3b98d322020-09-03 17:54:16 +00002649 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002650 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002651 return binderStatusFromStatusT(
2652 mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role));
Jiabin Huang3b98d322020-09-03 17:54:16 +00002653}
2654
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002655Status AudioPolicyService::getDevicesForRoleAndCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002656 AudioSource audioSourceAidl,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002657 media::DeviceRole roleAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002658 std::vector<AudioDevice>* _aidl_return) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002659 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovddceecc2021-09-03 13:58:56 -07002660 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002661 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2662 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2663 AudioDeviceTypeAddrVector devices;
2664
Jiabin Huang3b98d322020-09-03 17:54:16 +00002665 if (mAudioPolicyManager == nullptr) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002666 return binderStatusFromStatusT(NO_INIT);
Jiabin Huang3b98d322020-09-03 17:54:16 +00002667 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002668 audio_utils::lock_guard _l(mMutex);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002669 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2670 mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices)));
2671 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002672 convertContainer<std::vector<AudioDevice>>(devices,
2673 legacy2aidl_AudioDeviceTypeAddress));
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002674 return Status::ok();
Jiabin Huang3b98d322020-09-03 17:54:16 +00002675}
2676
Eric Laurent81dd0f52021-07-05 11:54:40 +02002677Status AudioPolicyService::getSpatializer(
2678 const sp<media::INativeSpatializerCallback>& callback,
2679 media::GetSpatializerResponse* _aidl_return) {
2680 _aidl_return->spatializer = nullptr;
Eric Laurent2be8b292021-08-23 09:44:33 -07002681 if (callback == nullptr) {
2682 return binderStatusFromStatusT(BAD_VALUE);
2683 }
Jean-Michel Trivi41628732021-09-09 12:16:21 -07002684 if (mSpatializer != nullptr) {
2685 RETURN_IF_BINDER_ERROR(
2686 binderStatusFromStatusT(mSpatializer->registerCallback(callback)));
2687 _aidl_return->spatializer = mSpatializer;
2688 }
Eric Laurent81dd0f52021-07-05 11:54:40 +02002689 return Status::ok();
2690}
2691
2692Status AudioPolicyService::canBeSpatialized(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002693 const std::optional<media::audio::common::AudioAttributes>& attrAidl,
Mikhail Naganovdbf03642021-08-25 18:15:32 -07002694 const std::optional<AudioConfig>& configAidl,
Mikhail Naganovf4a75362021-09-16 00:02:54 +00002695 const std::vector<AudioDevice>& devicesAidl,
Eric Laurent81dd0f52021-07-05 11:54:40 +02002696 bool* _aidl_return) {
2697 if (mAudioPolicyManager == nullptr) {
2698 return binderStatusFromStatusT(NO_INIT);
2699 }
2700 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
2701 if (attrAidl.has_value()) {
2702 attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002703 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl.value()));
Eric Laurent81dd0f52021-07-05 11:54:40 +02002704 }
2705 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
2706 if (configAidl.has_value()) {
2707 config = VALUE_OR_RETURN_BINDER_STATUS(
2708 aidl2legacy_AudioConfig_audio_config_t(configAidl.value(),
2709 false /*isInput*/));
2710 }
2711 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2712 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2713 aidl2legacy_AudioDeviceTypeAddress));
2714
Andy Hung79eacdb2023-11-30 19:34:24 -08002715 audio_utils::lock_guard _l(mMutex);
Eric Laurent81dd0f52021-07-05 11:54:40 +02002716 *_aidl_return = mAudioPolicyManager->canBeSpatialized(&attr, &config, devices);
2717 return Status::ok();
2718}
2719
Mikhail Naganov1c400902023-05-17 11:48:43 -07002720Status AudioPolicyService::getDirectPlaybackSupport(
2721 const media::audio::common::AudioAttributes &attrAidl,
2722 const AudioConfig &configAidl,
2723 media::AudioDirectMode *_aidl_return) {
jiabin2b9d5a12021-12-10 01:06:29 +00002724 if (mAudioPolicyManager == nullptr) {
2725 return binderStatusFromStatusT(NO_INIT);
2726 }
2727 if (_aidl_return == nullptr) {
2728 return binderStatusFromStatusT(BAD_VALUE);
2729 }
2730 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002731 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
jiabin2b9d5a12021-12-10 01:06:29 +00002732 audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
2733 aidl2legacy_AudioConfig_audio_config_t(configAidl, false /*isInput*/));
Andy Hung79eacdb2023-11-30 19:34:24 -08002734 audio_utils::lock_guard _l(mMutex);
jiabin2b9d5a12021-12-10 01:06:29 +00002735 *_aidl_return = static_cast<media::AudioDirectMode>(
2736 VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_direct_mode_t_int32_t_mask(
2737 mAudioPolicyManager->getDirectPlaybackSupport(&attr, &config))));
2738 return Status::ok();
2739}
2740
Dorin Drimusf2196d82022-01-03 12:11:18 +01002741Status AudioPolicyService::getDirectProfilesForAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002742 const media::audio::common::AudioAttributes& attrAidl,
Dorin Drimusf2196d82022-01-03 12:11:18 +01002743 std::vector<media::audio::common::AudioProfile>* _aidl_return) {
2744 if (mAudioPolicyManager == nullptr) {
2745 return binderStatusFromStatusT(NO_INIT);
2746 }
2747 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002748 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
Dorin Drimusf2196d82022-01-03 12:11:18 +01002749 AudioProfileVector audioProfiles;
2750
Andy Hung79eacdb2023-11-30 19:34:24 -08002751 audio_utils::lock_guard _l(mMutex);
Dorin Drimusf2196d82022-01-03 12:11:18 +01002752 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2753 mAudioPolicyManager->getDirectProfilesForAttributes(&attr, audioProfiles)));
2754 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2755 convertContainer<std::vector<media::audio::common::AudioProfile>>(
2756 audioProfiles, legacy2aidl_AudioProfile_common, false /*isInput*/));
2757
2758 return Status::ok();
2759}
2760
jiabina84c3d32022-12-02 18:59:55 +00002761Status AudioPolicyService::getSupportedMixerAttributes(
2762 int32_t portIdAidl, std::vector<media::AudioMixerAttributesInternal>* _aidl_return) {
2763 if (mAudioPolicyManager == nullptr) {
2764 return binderStatusFromStatusT(NO_INIT);
2765 }
2766
2767 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2768 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2769
2770 std::vector<audio_mixer_attributes_t> mixerAttrs;
Andy Hung79eacdb2023-11-30 19:34:24 -08002771 audio_utils::lock_guard _l(mMutex);
jiabina84c3d32022-12-02 18:59:55 +00002772 RETURN_IF_BINDER_ERROR(
2773 binderStatusFromStatusT(mAudioPolicyManager->getSupportedMixerAttributes(
2774 portId, mixerAttrs)));
2775 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2776 convertContainer<std::vector<media::AudioMixerAttributesInternal>>(
2777 mixerAttrs,
2778 legacy2aidl_audio_mixer_attributes_t_AudioMixerAttributesInternal));
2779 return Status::ok();
2780}
2781
2782Status AudioPolicyService::setPreferredMixerAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002783 const media::audio::common::AudioAttributes& attrAidl,
jiabina84c3d32022-12-02 18:59:55 +00002784 int32_t portIdAidl,
2785 int32_t uidAidl,
2786 const media::AudioMixerAttributesInternal& mixerAttrAidl) {
2787 if (mAudioPolicyManager == nullptr) {
2788 return binderStatusFromStatusT(NO_INIT);
2789 }
2790
2791 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002792 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
jiabina84c3d32022-12-02 18:59:55 +00002793 audio_mixer_attributes_t mixerAttr = VALUE_OR_RETURN_BINDER_STATUS(
2794 aidl2legacy_AudioMixerAttributesInternal_audio_mixer_attributes_t(mixerAttrAidl));
2795 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2796 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2797 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2798
Andy Hung79eacdb2023-11-30 19:34:24 -08002799 audio_utils::lock_guard _l(mMutex);
jiabina84c3d32022-12-02 18:59:55 +00002800 return binderStatusFromStatusT(
2801 mAudioPolicyManager->setPreferredMixerAttributes(&attr, portId, uid, &mixerAttr));
2802}
2803
2804Status AudioPolicyService::getPreferredMixerAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002805 const media::audio::common::AudioAttributes& attrAidl,
jiabina84c3d32022-12-02 18:59:55 +00002806 int32_t portIdAidl,
2807 std::optional<media::AudioMixerAttributesInternal>* _aidl_return) {
2808 if (mAudioPolicyManager == nullptr) {
2809 return binderStatusFromStatusT(NO_INIT);
2810 }
2811
2812 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002813 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
jiabina84c3d32022-12-02 18:59:55 +00002814 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2815 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2816
Andy Hung79eacdb2023-11-30 19:34:24 -08002817 audio_utils::lock_guard _l(mMutex);
jiabina84c3d32022-12-02 18:59:55 +00002818 audio_mixer_attributes_t mixerAttr = AUDIO_MIXER_ATTRIBUTES_INITIALIZER;
2819 RETURN_IF_BINDER_ERROR(
2820 binderStatusFromStatusT(mAudioPolicyManager->getPreferredMixerAttributes(
2821 &attr, portId, &mixerAttr)));
2822 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2823 legacy2aidl_audio_mixer_attributes_t_AudioMixerAttributesInternal(mixerAttr));
2824 return Status::ok();
2825}
2826
2827Status AudioPolicyService::clearPreferredMixerAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002828 const media::audio::common::AudioAttributes& attrAidl,
jiabina84c3d32022-12-02 18:59:55 +00002829 int32_t portIdAidl,
2830 int32_t uidAidl) {
2831 if (mAudioPolicyManager == nullptr) {
2832 return binderStatusFromStatusT(NO_INIT);
2833 }
2834
2835 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
Mikhail Naganov1c400902023-05-17 11:48:43 -07002836 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
jiabina84c3d32022-12-02 18:59:55 +00002837 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2838 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2839 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2840
Andy Hung79eacdb2023-11-30 19:34:24 -08002841 audio_utils::lock_guard _l(mMutex);
jiabina84c3d32022-12-02 18:59:55 +00002842 return binderStatusFromStatusT(
2843 mAudioPolicyManager->clearPreferredMixerAttributes(&attr, portId, uid));
2844}
2845
Atneya Nair9f91a5e2024-05-09 16:25:05 -07002846Status AudioPolicyService::getPermissionController(sp<INativePermissionController>* out) {
2847 *out = mPermissionController;
2848 return Status::ok();
2849}
2850
Jiabin Huangaa6e9e32024-10-21 17:19:28 +00002851Status AudioPolicyService::getMmapPolicyInfos(
2852 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *_aidl_return) {
2853 if (mAudioPolicyManager == nullptr) {
2854 return binderStatusFromStatusT(NO_INIT);
2855 }
2856 audio_utils::lock_guard _l(mMutex);
2857 return binderStatusFromStatusT(
2858 mAudioPolicyManager->getMmapPolicyInfos(policyType, _aidl_return));
2859}
2860
2861Status AudioPolicyService::getMmapPolicyForDevice(
2862 AudioMMapPolicyType policyType, AudioMMapPolicyInfo *policyInfo) {
2863 if (mAudioPolicyManager == nullptr) {
2864 return binderStatusFromStatusT(NO_INIT);
2865 }
2866 audio_utils::lock_guard _l(mMutex);
2867 return binderStatusFromStatusT(
2868 mAudioPolicyManager->getMmapPolicyForDevice(policyType, policyInfo));
2869}
2870
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002871} // namespace android