1 /*
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
17 #define LOG_TAG "AudioPolicyInterfaceImpl"
18 //#define LOG_NDEBUG 0
19
20 #include "AudioPolicyService.h"
21 #include "AudioRecordClient.h"
22 #include "TypeConverter.h"
23
24 #include <android/content/AttributionSourceState.h>
25 #include <android_media_audiopolicy.h>
26 #include <android_media_audio.h>
27 #include <binder/Enums.h>
28 #include <com_android_media_audio.h>
29 #include <cutils/properties.h>
30 #include <error/expected_utils.h>
31 #include <media/AidlConversion.h>
32 #include <media/AudioPolicy.h>
33 #include <media/AudioValidator.h>
34 #include <media/MediaMetricsItem.h>
35 #include <media/PolicyAidlConversion.h>
36 #include <utils/Log.h>
37
38 #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
43 #define RETURN_BINDER_STATUS_IF_ERROR(x) \
44 if (status_t _tmp = (x); _tmp != OK) return aidl_utils::binderStatusFromStatusT(_tmp);
45
46 #define RETURN_IF_BINDER_ERROR(x) \
47 { \
48 binder::Status _tmp = (x); \
49 if (!_tmp.isOk()) return _tmp; \
50 }
51
52 #define CHECK_PERM(expr1, expr2) \
53 VALUE_OR_RETURN_STATUS(getPermissionProvider().checkPermission((expr1), (expr2)))
54
55 #define PROPAGATE_FALSEY(val) do { if (!val.has_value() || !val.value()) return val; } while (0)
56
57 #define MAX_ITEMS_PER_LIST 1024
58
59 namespace android {
60 namespace audiopolicy_flags = android::media::audiopolicy;
61 using binder::Status;
62 using aidl_utils::binderStatusFromStatusT;
63 using android::media::audio::concurrent_audio_record_bypass_permission;
64 using com::android::media::audio::audioserver_permissions;
65 using com::android::media::permission::NativePermissionController;
66 using com::android::media::permission::PermissionEnum;
67 using com::android::media::permission::PermissionEnum::ACCESS_ULTRASOUND;
68 using com::android::media::permission::PermissionEnum::CALL_AUDIO_INTERCEPTION;
69 using com::android::media::permission::PermissionEnum::CAPTURE_AUDIO_HOTWORD;
70 using com::android::media::permission::PermissionEnum::CAPTURE_VOICE_COMMUNICATION_OUTPUT;
71 using com::android::media::permission::PermissionEnum::CAPTURE_AUDIO_OUTPUT;
72 using com::android::media::permission::PermissionEnum::CAPTURE_MEDIA_OUTPUT;
73 using com::android::media::permission::PermissionEnum::CAPTURE_TUNER_AUDIO_INPUT;
74 using com::android::media::permission::PermissionEnum::MODIFY_AUDIO_ROUTING;
75 using com::android::media::permission::PermissionEnum::MODIFY_AUDIO_SETTINGS;
76 using com::android::media::permission::PermissionEnum::MODIFY_AUDIO_SETTINGS_PRIVILEGED;
77 using com::android::media::permission::PermissionEnum::MODIFY_DEFAULT_AUDIO_EFFECTS;
78 using com::android::media::permission::PermissionEnum::MODIFY_PHONE_STATE;
79 using com::android::media::permission::PermissionEnum::RECORD_AUDIO;
80 using com::android::media::permission::PermissionEnum::WRITE_SECURE_SETTINGS;
81 using com::android::media::permission::PermissionEnum::BLUETOOTH_CONNECT;
82 using com::android::media::permission::PermissionEnum::BYPASS_CONCURRENT_RECORD_AUDIO_RESTRICTION;
83 using content::AttributionSourceState;
84 using media::audio::common::AudioConfig;
85 using media::audio::common::AudioConfigBase;
86 using media::audio::common::AudioDevice;
87 using media::audio::common::AudioDeviceAddress;
88 using media::audio::common::AudioDeviceDescription;
89 using media::audio::common::AudioFormatDescription;
90 using media::audio::common::AudioMode;
91 using media::audio::common::AudioOffloadInfo;
92 using media::audio::common::AudioSource;
93 using media::audio::common::AudioStreamType;
94 using media::audio::common::AudioUsage;
95 using media::audio::common::AudioUuid;
96 using media::audio::common::Int;
97
98 constexpr int kDefaultVirtualDeviceId = 0;
99 namespace {
100 constexpr auto PERMISSION_HARD_DENIED = permission::PermissionChecker::PERMISSION_HARD_DENIED;
101 constexpr auto PERMISSION_GRANTED = permission::PermissionChecker::PERMISSION_GRANTED;
102
mustAnonymizeBluetoothAddress(const AttributionSourceState & attributionSource,const String16 & caller,const IPermissionProvider & provider)103 bool mustAnonymizeBluetoothAddress(const AttributionSourceState& attributionSource,
104 const String16& caller,
105 const IPermissionProvider& provider) {
106 if (audioserver_permissions()) {
107 switch(multiuser_get_app_id(attributionSource.uid)) {
108 // out of caution, to prevent regression
109 case AID_ROOT:
110 case AID_SYSTEM:
111 case AID_AUDIOSERVER:
112 case AID_RADIO:
113 case AID_BLUETOOTH:
114 case AID_MEDIA:
115 return false;
116 }
117 const auto res = provider.checkPermission(BLUETOOTH_CONNECT, attributionSource.uid);
118 if (res.has_value()) {
119 return !(*res);
120 } else {
121 ALOGE("%s: error: %s", __func__, res.error().toString8().c_str());
122 return true;
123 }
124 } else {
125 return mustAnonymizeBluetoothAddressLegacy(attributionSource, caller);
126 }
127 }
128
129 }
130
131 const std::vector<audio_usage_t>& SYSTEM_USAGES = {
132 AUDIO_USAGE_CALL_ASSISTANT,
133 AUDIO_USAGE_EMERGENCY,
134 AUDIO_USAGE_SAFETY,
135 AUDIO_USAGE_VEHICLE_STATUS,
136 AUDIO_USAGE_ANNOUNCEMENT
137 };
138
isSystemUsage(audio_usage_t usage)139 bool isSystemUsage(audio_usage_t usage) {
140 return std::find(std::begin(SYSTEM_USAGES), std::end(SYSTEM_USAGES), usage)
141 != std::end(SYSTEM_USAGES);
142 }
143
isSupportedSystemUsage(audio_usage_t usage)144 bool AudioPolicyService::isSupportedSystemUsage(audio_usage_t usage) {
145 return std::find(std::begin(mSupportedSystemUsages), std::end(mSupportedSystemUsages), usage)
146 != std::end(mSupportedSystemUsages);
147 }
148
validateUsage(const audio_attributes_t & attr)149 Status AudioPolicyService::validateUsage(const audio_attributes_t& attr) {
150 return validateUsage(attr, getCallingAttributionSource());
151 }
152
validateUsage(const audio_attributes_t & attr,const AttributionSourceState & attributionSource)153 Status AudioPolicyService::validateUsage(const audio_attributes_t& attr,
154 const AttributionSourceState& attributionSource) {
155 if (isSystemUsage(attr.usage)) {
156 if (isSupportedSystemUsage(attr.usage)) {
157 if (attr.usage == AUDIO_USAGE_CALL_ASSISTANT
158 && ((attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0)) {
159 if (!(audioserver_permissions() ?
160 CHECK_PERM(CALL_AUDIO_INTERCEPTION, attributionSource.uid)
161 : callAudioInterceptionAllowed(attributionSource))) {
162 ALOGE("%s: call audio interception not allowed for attribution source: %s",
163 __func__, attributionSource.toString().c_str());
164 return Status::fromExceptionCode(Status::EX_SECURITY,
165 "Call audio interception not allowed");
166 }
167 } else if (!(audioserver_permissions() ?
168 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
169 : modifyAudioRoutingAllowed(attributionSource))) {
170 ALOGE("%s: modify audio routing not allowed for attribution source: %s",
171 __func__, attributionSource.toString().c_str());
172 return Status::fromExceptionCode(Status::EX_SECURITY,
173 "Modify audio routing not allowed");
174 }
175 } else {
176 return Status::fromExceptionCode(Status::EX_ILLEGAL_ARGUMENT);
177 }
178 }
179 return Status::ok();
180 }
181
182
183
184 // ----------------------------------------------------------------------------
185
doOnNewAudioModulesAvailable()186 void AudioPolicyService::doOnNewAudioModulesAvailable()
187 {
188 if (mAudioPolicyManager == NULL) return;
189 audio_utils::lock_guard _l(mMutex);
190 AutoCallerClear acc;
191 mAudioPolicyManager->onNewAudioModulesAvailable();
192 }
193
setDeviceConnectionState(media::AudioPolicyDeviceState stateAidl,const android::media::audio::common::AudioPort & port,const AudioFormatDescription & encodedFormatAidl)194 Status AudioPolicyService::setDeviceConnectionState(
195 media::AudioPolicyDeviceState stateAidl,
196 const android::media::audio::common::AudioPort& port,
197 const AudioFormatDescription& encodedFormatAidl) {
198 audio_policy_dev_state_t state = VALUE_OR_RETURN_BINDER_STATUS(
199 aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(stateAidl));
200 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
201 aidl2legacy_AudioFormatDescription_audio_format_t(encodedFormatAidl));
202
203 if (mAudioPolicyManager == NULL) {
204 return binderStatusFromStatusT(NO_INIT);
205 }
206 if (!(audioserver_permissions() ?
207 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
208 : settingsAllowed())) {
209 return binderStatusFromStatusT(PERMISSION_DENIED);
210 }
211 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
212 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
213 return binderStatusFromStatusT(BAD_VALUE);
214 }
215
216 ALOGV("setDeviceConnectionState()");
217 audio_utils::lock_guard _l(mMutex);
218 AutoCallerClear acc;
219 status_t status = mAudioPolicyManager->setDeviceConnectionState(
220 state, port, encodedFormat);
221 if (status == NO_ERROR) {
222 onCheckSpatializer_l();
223 }
224 return binderStatusFromStatusT(status);
225 }
226
getDeviceConnectionState(const AudioDevice & deviceAidl,media::AudioPolicyDeviceState * _aidl_return)227 Status AudioPolicyService::getDeviceConnectionState(const AudioDevice& deviceAidl,
228 media::AudioPolicyDeviceState* _aidl_return) {
229 audio_devices_t device;
230 std::string address;
231 RETURN_BINDER_STATUS_IF_ERROR(
232 aidl2legacy_AudioDevice_audio_device(deviceAidl, &device, &address));
233 if (mAudioPolicyManager == NULL) {
234 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
235 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
236 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
237 return Status::ok();
238 }
239 audio_utils::lock_guard _l(mMutex);
240 AutoCallerClear acc;
241 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
242 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
243 mAudioPolicyManager->getDeviceConnectionState(
244 device, address.c_str())));
245 return Status::ok();
246 }
247
handleDeviceConfigChange(const AudioDevice & deviceAidl,const std::string & deviceNameAidl,const AudioFormatDescription & encodedFormatAidl)248 Status AudioPolicyService::handleDeviceConfigChange(
249 const AudioDevice& deviceAidl,
250 const std::string& deviceNameAidl,
251 const AudioFormatDescription& encodedFormatAidl) {
252 audio_devices_t device;
253 std::string address;
254 RETURN_BINDER_STATUS_IF_ERROR(
255 aidl2legacy_AudioDevice_audio_device(deviceAidl, &device, &address));
256 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
257 aidl2legacy_AudioFormatDescription_audio_format_t(encodedFormatAidl));
258
259 if (mAudioPolicyManager == NULL) {
260 return binderStatusFromStatusT(NO_INIT);
261 }
262 if (!(audioserver_permissions() ?
263 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
264 : settingsAllowed())) {
265 return binderStatusFromStatusT(PERMISSION_DENIED);
266 }
267
268 ALOGV("handleDeviceConfigChange()");
269 audio_utils::lock_guard _l(mMutex);
270 AutoCallerClear acc;
271 status_t status = mAudioPolicyManager->handleDeviceConfigChange(
272 device, address.c_str(), deviceNameAidl.c_str(), encodedFormat);
273
274 if (status == NO_ERROR) {
275 onCheckSpatializer_l();
276 }
277 return binderStatusFromStatusT(status);
278 }
279
setPhoneState(AudioMode stateAidl,int32_t uidAidl)280 Status AudioPolicyService::setPhoneState(AudioMode stateAidl, int32_t uidAidl)
281 {
282 audio_mode_t state = VALUE_OR_RETURN_BINDER_STATUS(
283 aidl2legacy_AudioMode_audio_mode_t(stateAidl));
284 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
285 if (mAudioPolicyManager == NULL) {
286 return binderStatusFromStatusT(NO_INIT);
287 }
288 if (!(audioserver_permissions() ?
289 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
290 : settingsAllowed())) {
291 return binderStatusFromStatusT(PERMISSION_DENIED);
292 }
293 if (uint32_t(state) >= AUDIO_MODE_CNT) {
294 return binderStatusFromStatusT(BAD_VALUE);
295 }
296
297 ALOGV("setPhoneState()");
298
299 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
300 // operation from policy manager standpoint (no other operation (e.g track start or stop)
301 // can be interleaved).
302 audio_utils::lock_guard _l(mMutex);
303 // TODO: check if it is more appropriate to do it in platform specific policy manager
304
305 // Audio HAL mode conversion for call redirect modes
306 audio_mode_t halMode = state;
307 if (state == AUDIO_MODE_CALL_REDIRECT) {
308 halMode = AUDIO_MODE_CALL_SCREEN;
309 } else if (state == AUDIO_MODE_COMMUNICATION_REDIRECT) {
310 halMode = AUDIO_MODE_NORMAL;
311 }
312 AudioSystem::setMode(halMode);
313
314 AutoCallerClear acc;
315 mAudioPolicyManager->setPhoneState(state);
316 mPhoneState = state;
317 mPhoneStateOwnerUid = uid;
318 updateUidStates_l();
319 return Status::ok();
320 }
321
getPhoneState(AudioMode * _aidl_return)322 Status AudioPolicyService::getPhoneState(AudioMode* _aidl_return) {
323 audio_utils::lock_guard _l(mMutex);
324 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_mode_t_AudioMode(mPhoneState));
325 return Status::ok();
326 }
327
setForceUse(media::AudioPolicyForceUse usageAidl,media::AudioPolicyForcedConfig configAidl)328 Status AudioPolicyService::setForceUse(media::AudioPolicyForceUse usageAidl,
329 media::AudioPolicyForcedConfig configAidl)
330 {
331 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
332 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
333 audio_policy_forced_cfg_t config = VALUE_OR_RETURN_BINDER_STATUS(
334 aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl));
335
336 if (mAudioPolicyManager == NULL) {
337 return binderStatusFromStatusT(NO_INIT);
338 }
339
340 if (!(audioserver_permissions() ?
341 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
342 : modifyAudioRoutingAllowed())) {
343 return binderStatusFromStatusT(PERMISSION_DENIED);
344 }
345
346 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
347 return binderStatusFromStatusT(BAD_VALUE);
348 }
349 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
350 return binderStatusFromStatusT(BAD_VALUE);
351 }
352 ALOGV("setForceUse()");
353 audio_utils::lock_guard _l(mMutex);
354 AutoCallerClear acc;
355 mAudioPolicyManager->setForceUse(usage, config);
356 onCheckSpatializer_l();
357 return Status::ok();
358 }
359
getForceUse(media::AudioPolicyForceUse usageAidl,media::AudioPolicyForcedConfig * _aidl_return)360 Status AudioPolicyService::getForceUse(media::AudioPolicyForceUse usageAidl,
361 media::AudioPolicyForcedConfig* _aidl_return) {
362 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
363 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
364
365 if (mAudioPolicyManager == NULL) {
366 return binderStatusFromStatusT(NO_INIT);
367 }
368 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
369 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
370 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(AUDIO_POLICY_FORCE_NONE));
371 return Status::ok();
372 }
373 AutoCallerClear acc;
374 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
375 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
376 mAudioPolicyManager->getForceUse(usage)));
377 return Status::ok();
378 }
379
getOutput(AudioStreamType streamAidl,int32_t * _aidl_return)380 Status AudioPolicyService::getOutput(AudioStreamType streamAidl, int32_t* _aidl_return)
381 {
382 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
383 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
384
385 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT
386 && stream != AUDIO_STREAM_ASSISTANT && stream != AUDIO_STREAM_CALL_ASSISTANT) {
387 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
388 legacy2aidl_audio_io_handle_t_int32_t(AUDIO_IO_HANDLE_NONE));
389 return Status::ok();
390 }
391 if (mAudioPolicyManager == NULL) {
392 return binderStatusFromStatusT(NO_INIT);
393 }
394 ALOGV("getOutput()");
395 audio_utils::lock_guard _l(mMutex);
396 AutoCallerClear acc;
397 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
398 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutput(stream)));
399 return Status::ok();
400 }
401
getOutputForAttr(const media::audio::common::AudioAttributes & attrAidl,int32_t sessionAidl,const AttributionSourceState & attributionSource,const AudioConfig & configAidl,int32_t flagsAidl,const std::vector<int32_t> & selectedDeviceIdsAidl,media::GetOutputForAttrResponse * _aidl_return)402 Status AudioPolicyService::getOutputForAttr(const media::audio::common::AudioAttributes& attrAidl,
403 int32_t sessionAidl,
404 const AttributionSourceState& attributionSource,
405 const AudioConfig& configAidl,
406 int32_t flagsAidl,
407 const std::vector<int32_t>& selectedDeviceIdsAidl,
408 media::GetOutputForAttrResponse* _aidl_return)
409 {
410 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
411 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
412 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
413 aidl2legacy_int32_t_audio_session_t(sessionAidl));
414 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
415 audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
416 aidl2legacy_AudioConfig_audio_config_t(configAidl, false /*isInput*/));
417 audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
418 aidl2legacy_int32_t_audio_output_flags_t_mask(flagsAidl));
419 DeviceIdVector selectedDeviceIds = VALUE_OR_RETURN_BINDER_STATUS(
420 convertContainer<DeviceIdVector>(selectedDeviceIdsAidl,
421 aidl2legacy_int32_t_audio_port_handle_t));
422
423 audio_io_handle_t output;
424 audio_port_handle_t portId;
425 std::vector<audio_io_handle_t> secondaryOutputs;
426
427 if (mAudioPolicyManager == NULL) {
428 return binderStatusFromStatusT(NO_INIT);
429 }
430
431 RETURN_IF_BINDER_ERROR(
432 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
433 RETURN_IF_BINDER_ERROR(validateUsage(attr, attributionSource));
434
435 ALOGV("%s()", __func__);
436 audio_utils::lock_guard _l(mMutex);
437
438 if (!mPackageManager.allowPlaybackCapture(VALUE_OR_RETURN_BINDER_STATUS(
439 aidl2legacy_int32_t_uid_t(attributionSource.uid)))) {
440 attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
441 }
442 const bool bypassInterruptionAllowed = audioserver_permissions() ? (
443 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid) ||
444 CHECK_PERM(MODIFY_PHONE_STATE, attributionSource.uid) ||
445 CHECK_PERM(WRITE_SECURE_SETTINGS, attributionSource.uid))
446 : bypassInterruptionPolicyAllowed(attributionSource);
447
448 if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
449 && !bypassInterruptionAllowed) {
450 attr.flags = static_cast<audio_flags_mask_t>(
451 attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
452 }
453
454 if (attr.content_type == AUDIO_CONTENT_TYPE_ULTRASOUND) {
455 if (!(audioserver_permissions() ?
456 CHECK_PERM(ACCESS_ULTRASOUND, attributionSource.uid)
457 : accessUltrasoundAllowed(attributionSource))) {
458 ALOGE("%s: permission denied: ultrasound not allowed for uid %d pid %d",
459 __func__, attributionSource.uid, attributionSource.pid);
460 return binderStatusFromStatusT(PERMISSION_DENIED);
461 }
462 }
463
464 //TODO this permission check should extend to all system usages
465 if (attr.usage == AUDIO_USAGE_SPEAKER_CLEANUP) {
466 if (!(audioserver_permissions() ?
467 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
468 : modifyAudioRoutingAllowed())) {
469 ALOGE("%s: permission denied: SPEAKER_CLEANUP not allowed for uid %d pid %d",
470 __func__, attributionSource.uid, attributionSource.pid);
471 return binderStatusFromStatusT(PERMISSION_DENIED);
472 }
473 }
474
475 if (strlen(attr.tags) != 0) {
476 const bool audioAttributesTagsAllowed = audioserver_permissions() ? (
477 CHECK_PERM(MODIFY_AUDIO_SETTINGS_PRIVILEGED, attributionSource.uid) ||
478 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid) ||
479 CHECK_PERM(CALL_AUDIO_INTERCEPTION, attributionSource.uid) ||
480 CHECK_PERM(CAPTURE_MEDIA_OUTPUT, attributionSource.uid) ||
481 CHECK_PERM(CAPTURE_VOICE_COMMUNICATION_OUTPUT, attributionSource.uid))
482 : (modifyAudioSettingsPrivilegedAllowed(attributionSource) ||
483 modifyAudioRoutingAllowed() ||
484 callAudioInterceptionAllowed(attributionSource) ||
485 captureMediaOutputAllowed(attributionSource) ||
486 captureVoiceCommunicationOutputAllowed(attributionSource));
487 if (!audioAttributesTagsAllowed) {
488 ALOGE("%s: permission denied: audio attributes tags not allowed for uid %d pid %d",
489 __func__, attributionSource.uid, attributionSource.pid);
490 return binderStatusFromStatusT(PERMISSION_DENIED);
491 }
492 }
493
494 AutoCallerClear acc;
495 AudioPolicyInterface::output_type_t outputType;
496 bool isSpatialized = false;
497 bool isBitPerfect = false;
498 float volume;
499 bool muted;
500 status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
501 &stream,
502 attributionSource,
503 &config,
504 &flags, &selectedDeviceIds, &portId,
505 &secondaryOutputs,
506 &outputType,
507 &isSpatialized,
508 &isBitPerfect,
509 &volume,
510 &muted);
511
512 // FIXME: Introduce a way to check for the the telephony device before opening the output
513 if (result == NO_ERROR) {
514 // enforce permission (if any) required for each type of input
515 switch (outputType) {
516 case AudioPolicyInterface::API_OUTPUT_LEGACY:
517 break;
518 case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
519 if (((attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0)
520 && !(audioserver_permissions() ?
521 CHECK_PERM(CALL_AUDIO_INTERCEPTION, attributionSource.uid)
522 : callAudioInterceptionAllowed(attributionSource))) {
523 ALOGE("%s() permission denied: call redirection not allowed for uid %d",
524 __func__, attributionSource.uid);
525 result = PERMISSION_DENIED;
526 } else if (!(audioserver_permissions() ?
527 CHECK_PERM(MODIFY_PHONE_STATE, attributionSource.uid)
528 : modifyPhoneStateAllowed(attributionSource))) {
529 ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
530 __func__, attributionSource.uid);
531 result = PERMISSION_DENIED;
532 }
533 break;
534 case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
535 if (!(audioserver_permissions() ?
536 CHECK_PERM(MODIFY_AUDIO_ROUTING, attributionSource.uid)
537 : modifyAudioRoutingAllowed(attributionSource))) {
538 ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
539 __func__, attributionSource.uid);
540 result = PERMISSION_DENIED;
541 }
542 break;
543 case AudioPolicyInterface::API_OUTPUT_INVALID:
544 default:
545 LOG_ALWAYS_FATAL("%s() encountered an invalid output type %d",
546 __func__, (int)outputType);
547 }
548 }
549
550 if (result == NO_ERROR) {
551 // usecase validator is disabled by default
552 if (property_get_bool("ro.audio.usecase_validator_enabled", false /* default */)) {
553 attr = VALUE_OR_RETURN_BINDER_STATUS(
554 mUsecaseValidator->verifyAudioAttributes(output, attributionSource, attr));
555 }
556
557 sp<AudioPlaybackClient> client =
558 new AudioPlaybackClient(attr, output, attributionSource, session,
559 portId, selectedDeviceIds, stream, isSpatialized, config.channel_mask);
560 mAudioPlaybackClients.add(portId, client);
561
562 _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
563 legacy2aidl_audio_io_handle_t_int32_t(output));
564 _aidl_return->stream = VALUE_OR_RETURN_BINDER_STATUS(
565 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
566 _aidl_return->selectedDeviceIds = VALUE_OR_RETURN_BINDER_STATUS(
567 convertContainer<std::vector<int32_t>>(selectedDeviceIds,
568 legacy2aidl_audio_port_handle_t_int32_t));
569 _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
570 legacy2aidl_audio_port_handle_t_int32_t(portId));
571 _aidl_return->secondaryOutputs = VALUE_OR_RETURN_BINDER_STATUS(
572 convertContainer<std::vector<int32_t>>(secondaryOutputs,
573 legacy2aidl_audio_io_handle_t_int32_t));
574 _aidl_return->isSpatialized = isSpatialized;
575 _aidl_return->isBitPerfect = isBitPerfect;
576 _aidl_return->attr = VALUE_OR_RETURN_BINDER_STATUS(
577 legacy2aidl_audio_attributes_t_AudioAttributes(attr));
578 _aidl_return->volume = volume;
579 _aidl_return->muted = muted;
580 } else {
581 _aidl_return->configBase.format = VALUE_OR_RETURN_BINDER_STATUS(
582 legacy2aidl_audio_format_t_AudioFormatDescription(config.format));
583 _aidl_return->configBase.channelMask = VALUE_OR_RETURN_BINDER_STATUS(
584 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(
585 config.channel_mask, false /*isInput*/));
586 _aidl_return->configBase.sampleRate = config.sample_rate;
587 }
588 return binderStatusFromStatusT(result);
589 }
590
getPlaybackClientAndEffects(audio_port_handle_t portId,sp<AudioPlaybackClient> & client,sp<AudioPolicyEffects> & effects,const char * context)591 void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
592 sp<AudioPlaybackClient>& client,
593 sp<AudioPolicyEffects>& effects,
594 const char *context)
595 {
596 audio_utils::lock_guard _l(mMutex);
597 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
598 if (index < 0) {
599 ALOGE("%s AudioTrack client not found for portId %d", context, portId);
600 return;
601 }
602 client = mAudioPlaybackClients.valueAt(index);
603 effects = mAudioPolicyEffects;
604 }
605
startOutput(int32_t portIdAidl)606 Status AudioPolicyService::startOutput(int32_t portIdAidl)
607 {
608 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
609 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
610 if (mAudioPolicyManager == NULL) {
611 return binderStatusFromStatusT(NO_INIT);
612 }
613 ALOGV("startOutput()");
614 sp<AudioPlaybackClient> client;
615 sp<AudioPolicyEffects> audioPolicyEffects;
616
617 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
618
619 if (audioPolicyEffects != 0) {
620 // create audio processors according to stream
621 status_t status = audioPolicyEffects->addOutputSessionEffects(client->io, client->stream,
622 client->session);
623 if (status != NO_ERROR && status != ALREADY_EXISTS) {
624 ALOGW("Failed to add effects on session %d", client->session);
625 }
626 }
627 audio_utils::lock_guard _l(mMutex);
628 AutoCallerClear acc;
629 status_t status = mAudioPolicyManager->startOutput(portId);
630 if (status == NO_ERROR) {
631 //TODO b/257922898: decide if/how we need to handle attributes update when playback starts
632 // or during playback
633 (void)mUsecaseValidator->startClient(client->io, client->portId, client->attributionSource,
634 client->attributes, nullptr /* callback */);
635 client->active = true;
636 onUpdateActiveSpatializerTracks_l();
637 }
638 return binderStatusFromStatusT(status);
639 }
640
stopOutput(int32_t portIdAidl)641 Status AudioPolicyService::stopOutput(int32_t portIdAidl)
642 {
643 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
644 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
645 if (mAudioPolicyManager == NULL) {
646 return binderStatusFromStatusT(NO_INIT);
647 }
648 ALOGV("stopOutput()");
649 mOutputCommandThread->stopOutputCommand(portId);
650 return Status::ok();
651 }
652
doStopOutput(audio_port_handle_t portId)653 status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
654 {
655 ALOGV("doStopOutput");
656 sp<AudioPlaybackClient> client;
657 sp<AudioPolicyEffects>audioPolicyEffects;
658
659 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
660
661 if (audioPolicyEffects != 0) {
662 // release audio processors from the stream
663 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
664 client->io, client->stream, client->session);
665 if (status != NO_ERROR && status != ALREADY_EXISTS) {
666 ALOGW("Failed to release effects on session %d", client->session);
667 }
668 }
669 audio_utils::lock_guard _l(mMutex);
670 AutoCallerClear acc;
671 status_t status = mAudioPolicyManager->stopOutput(portId);
672 if (status == NO_ERROR) {
673 client->active = false;
674 onUpdateActiveSpatializerTracks_l();
675 mUsecaseValidator->stopClient(client->io, client->portId);
676 }
677 return status;
678 }
679
releaseOutput(int32_t portIdAidl)680 Status AudioPolicyService::releaseOutput(int32_t portIdAidl)
681 {
682 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
683 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
684 if (mAudioPolicyManager == NULL) {
685 return binderStatusFromStatusT(NO_INIT);
686 }
687 ALOGV("releaseOutput()");
688 mOutputCommandThread->releaseOutputCommand(portId);
689 return Status::ok();
690 }
691
doReleaseOutput(audio_port_handle_t portId)692 void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
693 {
694 ALOGV("doReleaseOutput from tid %d", gettid());
695 sp<AudioPlaybackClient> client;
696 sp<AudioPolicyEffects> audioPolicyEffects;
697
698 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
699
700 if (audioPolicyEffects != 0 && client->active) {
701 // clean up effects if output was not stopped before being released
702 audioPolicyEffects->releaseOutputSessionEffects(
703 client->io, client->stream, client->session);
704 }
705 audio_utils::lock_guard _l(mMutex);
706 if (client != nullptr && client->active) {
707 onUpdateActiveSpatializerTracks_l();
708 }
709 mAudioPlaybackClients.removeItem(portId);
710 // called from internal thread: no need to clear caller identity
711 mAudioPolicyManager->releaseOutput(portId);
712 }
713
714 // These are sources for which CAPTURE_AUDIO_OUTPUT granted access
715 // for legacy reasons, before more specific permissions were deployed.
716 // TODO: remove this access
isLegacyOutputSource(AudioSource source)717 static bool isLegacyOutputSource(AudioSource source) {
718 switch (source) {
719 case AudioSource::VOICE_CALL:
720 case AudioSource::VOICE_DOWNLINK:
721 case AudioSource::VOICE_UPLINK:
722 case AudioSource::FM_TUNER:
723 return true;
724 default:
725 return false;
726 }
727 }
728
checkPermissionForInput(const AttributionSourceState & attrSource,const PermissionReqs & req)729 error::BinderResult<bool> AudioPolicyService::AudioPolicyClient::checkPermissionForInput(
730 const AttributionSourceState& attrSource, const PermissionReqs& req) {
731
732 error::BinderResult<bool> permRes = true;
733 const auto check_perm = [&](PermissionEnum perm, uid_t uid) {
734 return mAudioPolicyService->getPermissionProvider().checkPermission(perm, uid);
735 };
736 switch (req.source) {
737 case AudioSource::VOICE_UPLINK:
738 case AudioSource::VOICE_DOWNLINK:
739 case AudioSource::VOICE_CALL:
740 permRes = audioserver_permissions()
741 ? check_perm(CALL_AUDIO_INTERCEPTION, attrSource.uid)
742 : callAudioInterceptionAllowed(attrSource);
743 break;
744 case AudioSource::ECHO_REFERENCE:
745 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
746 : captureAudioOutputAllowed(attrSource);
747 break;
748 case AudioSource::FM_TUNER:
749 permRes = audioserver_permissions()
750 ? check_perm(CAPTURE_TUNER_AUDIO_INPUT, attrSource.uid)
751 : captureTunerAudioInputAllowed(attrSource);
752 break;
753 case AudioSource::HOTWORD:
754 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_HOTWORD, attrSource.uid)
755 : captureHotwordAllowed(attrSource);
756 break;
757 case AudioSource::ULTRASOUND:
758 permRes = audioserver_permissions() ? check_perm(ACCESS_ULTRASOUND, attrSource.uid)
759 : accessUltrasoundAllowed(attrSource);
760 break;
761 case AudioSource::SYS_RESERVED_INVALID:
762 case AudioSource::DEFAULT:
763 case AudioSource::MIC:
764 case AudioSource::CAMCORDER:
765 case AudioSource::VOICE_RECOGNITION:
766 case AudioSource::VOICE_COMMUNICATION:
767 case AudioSource::UNPROCESSED:
768 case AudioSource::VOICE_PERFORMANCE:
769 // No additional check intended
770 case AudioSource::REMOTE_SUBMIX:
771 // special-case checked based on mix type below
772 break;
773 }
774
775 if (!permRes.has_value()) return permRes;
776 if (!permRes.value()) {
777 if (isLegacyOutputSource(req.source)) {
778 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
779 : captureAudioOutputAllowed(attrSource);
780 PROPAGATE_FALSEY(permRes);
781 } else {
782 return false;
783 }
784 }
785
786 if (req.isHotword) {
787 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_HOTWORD, attrSource.uid)
788 : captureHotwordAllowed(attrSource);
789 PROPAGATE_FALSEY(permRes);
790 }
791
792 // TODO evaluate whether we should be checking call redirection like this
793 bool isAllowedDueToCallPerm = false;
794 if (req.isCallRedir) {
795 const auto checkCall = audioserver_permissions()
796 ? check_perm(CALL_AUDIO_INTERCEPTION, attrSource.uid)
797 : callAudioInterceptionAllowed(attrSource);
798 isAllowedDueToCallPerm = VALUE_OR_RETURN(checkCall);
799 }
800
801 switch (req.mixType) {
802 case MixType::NONE:
803 break;
804 case MixType::PUBLIC_CAPTURE_PLAYBACK:
805 // this use case has been validated in audio service with a MediaProjection token,
806 // and doesn't rely on regular permissions
807 // TODO (b/378778313)
808 break;
809 case MixType::TELEPHONY_RX_CAPTURE:
810 if (isAllowedDueToCallPerm) break;
811 // FIXME: use the same permission as for remote submix for now.
812 FALLTHROUGH_INTENDED;
813 case MixType::CAPTURE:
814 permRes = audioserver_permissions() ? check_perm(CAPTURE_AUDIO_OUTPUT, attrSource.uid)
815 : captureAudioOutputAllowed(attrSource);
816 break;
817 case MixType::EXT_POLICY_REROUTE:
818 // TODO intended?
819 if (isAllowedDueToCallPerm) break;
820 permRes = audioserver_permissions() ? check_perm(MODIFY_AUDIO_ROUTING, attrSource.uid)
821 : modifyAudioRoutingAllowed(attrSource);
822 break;
823 }
824
825 PROPAGATE_FALSEY(permRes);
826
827 // All sources which aren't output capture
828 // AND capture from vdi policy mix (the injected audio is mic data from another device)
829 // REQUIRE RECORD perms
830 const auto legacySource = aidl2legacy_AudioSource_audio_source_t(req.source).value();
831 if (req.virtualDeviceId != kDefaultVirtualDeviceId) {
832 // TODO assert that this is always a recordOpSource
833 // TODO upcall solution
834 return recordingAllowed(attrSource, req.virtualDeviceId, legacySource);
835 }
836
837 if (isRecordOpRequired(legacySource)) {
838 permRes = audioserver_permissions() ? check_perm(RECORD_AUDIO, attrSource.uid)
839 : recordingAllowed(attrSource, legacySource);
840 PROPAGATE_FALSEY(permRes);
841 }
842 return true;
843 }
844
getInputForAttr(const media::audio::common::AudioAttributes & attrAidl,int32_t inputAidl,int32_t riidAidl,int32_t sessionAidl,const AttributionSourceState & attributionSource,const AudioConfigBase & configAidl,int32_t flagsAidl,int32_t selectedDeviceIdAidl,media::GetInputForAttrResponse * _aidl_return)845 Status AudioPolicyService::getInputForAttr(const media::audio::common::AudioAttributes& attrAidl,
846 int32_t inputAidl,
847 int32_t riidAidl,
848 int32_t sessionAidl,
849 const AttributionSourceState& attributionSource,
850 const AudioConfigBase& configAidl,
851 int32_t flagsAidl,
852 int32_t selectedDeviceIdAidl,
853 media::GetInputForAttrResponse* _aidl_return) {
854 auto inputSource = attrAidl.source;
855 const audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
856 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
857 const audio_io_handle_t requestedInput = VALUE_OR_RETURN_BINDER_STATUS(
858 aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
859 const audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
860 aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
861 const audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
862 aidl2legacy_int32_t_audio_session_t(sessionAidl));
863 const audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
864 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl, true /*isInput*/));
865 const audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
866 aidl2legacy_int32_t_audio_input_flags_t_mask(flagsAidl));
867 const audio_port_handle_t requestedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
868 aidl2legacy_int32_t_audio_port_handle_t(selectedDeviceIdAidl));
869
870 if (mAudioPolicyManager == NULL) {
871 return binderStatusFromStatusT(NO_INIT);
872 }
873
874 RETURN_IF_BINDER_ERROR(
875 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
876
877 if (inputSource == AudioSource::SYS_RESERVED_INVALID ||
878 std::find(enum_range<AudioSource>().begin(), enum_range<AudioSource>().end(),
879 inputSource) == enum_range<AudioSource>().end()) {
880 return binderStatusFromStatusT(BAD_VALUE);
881 }
882
883 if (inputSource == AudioSource::DEFAULT) {
884 inputSource = AudioSource::MIC;
885 }
886
887 const bool isCallRedir = (attr.flags & AUDIO_FLAG_CALL_REDIRECTION) != 0;
888
889 //TODO(b/374751406): remove forcing canBypassConcurrentPolicy to canCaptureOutput
890 // once all system apps using CAPTURE_AUDIO_OUTPUT to capture during calls
891 // are updated to use the new CONCURRENT_AUDIO_RECORD_BYPASS permission.
892 bool canBypassConcurrentPolicy = audioserver_permissions()
893 ? CHECK_PERM(CAPTURE_AUDIO_OUTPUT, attributionSource.uid)
894 : captureAudioOutputAllowed(attributionSource);
895 if (concurrent_audio_record_bypass_permission()) {
896 canBypassConcurrentPolicy = audioserver_permissions() ?
897 CHECK_PERM(BYPASS_CONCURRENT_RECORD_AUDIO_RESTRICTION,
898 attributionSource.uid)
899 : bypassConcurrentPolicyAllowed(attributionSource);
900 }
901
902 sp<AudioPolicyEffects> audioPolicyEffects;
903 base::expected<media::GetInputForAttrResponse, std::variant<binder::Status, AudioConfigBase>>
904 res;
905 {
906 audio_utils::lock_guard _l(mMutex);
907 AutoCallerClear acc;
908 // the audio_in_acoustics_t parameter is ignored by get_input()
909 res = mAudioPolicyManager->getInputForAttr(attr, requestedInput, requestedDeviceId,
910 config, flags, riid, session,
911 attributionSource);
912 if (!res.has_value()) {
913 if (res.error().index() == 1) {
914 _aidl_return->config = std::get<1>(res.error());
915 return Status::fromExceptionCode(EX_ILLEGAL_STATE);
916 } else {
917 return std::get<0>(res.error());
918 }
919 }
920
921 audioPolicyEffects = mAudioPolicyEffects;
922
923 sp<AudioRecordClient> client = new AudioRecordClient(
924 attr, res->input, session, res->portId, {res->selectedDeviceId}, attributionSource,
925 res->virtualDeviceId, canBypassConcurrentPolicy, mOutputCommandThread);
926 mAudioRecordClients.add(res->portId, client);
927 }
928
929 if (audioPolicyEffects != nullptr) {
930 // create audio pre processors according to input source
931 status_t status = audioPolicyEffects->addInputEffects(res->input,
932 aidl2legacy_AudioSource_audio_source_t(inputSource).value(), session);
933 if (status != NO_ERROR && status != ALREADY_EXISTS) {
934 ALOGW("Failed to add effects on input %d", res->input);
935 }
936 }
937
938 *_aidl_return = res.value();
939
940 return Status::ok();
941 }
942
getDeviceTypeStrForPortId(audio_port_handle_t portId)943 std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
944 struct audio_port_v7 port = {};
945 port.id = portId;
946 status_t status = mAudioPolicyManager->getAudioPort(&port);
947 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
948 return toString(port.ext.device.type);
949 }
950 return {};
951 }
952
getDeviceTypeStrForPortIds(DeviceIdVector portIds)953 std::string AudioPolicyService::getDeviceTypeStrForPortIds(DeviceIdVector portIds) {
954 std::string output = {};
955 for (auto it = portIds.begin(); it != portIds.end(); ++it) {
956 if (it != portIds.begin()) {
957 output += ", ";
958 }
959 output += getDeviceTypeStrForPortId(*it);
960 }
961 return output;
962 }
963
startInput(int32_t portIdAidl)964 Status AudioPolicyService::startInput(int32_t portIdAidl)
965 {
966 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
967 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
968
969 if (mAudioPolicyManager == NULL) {
970 return binderStatusFromStatusT(NO_INIT);
971 }
972 sp<AudioRecordClient> client;
973 {
974 audio_utils::lock_guard _l(mMutex);
975
976 ssize_t index = mAudioRecordClients.indexOfKey(portId);
977 if (index < 0) {
978 return binderStatusFromStatusT(INVALID_OPERATION);
979 }
980 client = mAudioRecordClients.valueAt(index);
981 }
982
983 std::stringstream msg;
984 msg << "Audio recording on session " << client->session;
985
986 const auto permitted = startRecording(client->attributionSource, client->virtualDeviceId,
987 String16(msg.str().c_str()), client->attributes.source);
988
989 // check calling permissions
990 if (permitted == PERMISSION_HARD_DENIED) {
991 ALOGE("%s permission denied: recording not allowed for attribution source %s",
992 __func__, client->attributionSource.toString().c_str());
993 return binderStatusFromStatusT(PERMISSION_DENIED);
994 }
995
996 audio_utils::lock_guard _l(mMutex);
997
998 ALOGW_IF(client->silenced, "startInput on silenced input for port %d, uid %d. Unsilencing.",
999 portIdAidl,
1000 client->attributionSource.uid);
1001
1002 if (client->active) {
1003 ALOGE("Client should never be active before startInput. Uid %d port %d",
1004 client->attributionSource.uid, portId);
1005 finishRecording(client->attributionSource, client->virtualDeviceId,
1006 client->attributes.source);
1007 return binderStatusFromStatusT(INVALID_OPERATION);
1008 }
1009
1010 // Force the possibly silenced client to match the state on the appops side
1011 // following the call to startRecording (i.e. unsilenced iff call succeeded)
1012 // At this point in time, the client is inactive, so no calls to appops are
1013 // sent in setAppState_l. This ensures existing clients have the same
1014 // behavior as new clients.
1015 // TODO(b/282076713)
1016 if (permitted == PERMISSION_GRANTED) {
1017 setAppState_l(client, APP_STATE_TOP);
1018 } else {
1019 setAppState_l(client, APP_STATE_IDLE);
1020 }
1021
1022 client->active = true;
1023 client->startTimeNs = systemTime();
1024 // This call updates the silenced state, and since we are active, appropriately notifies appops
1025 // if we silence the track.
1026 updateUidStates_l();
1027
1028 status_t status;
1029 {
1030 AutoCallerClear acc;
1031 status = mAudioPolicyManager->startInput(portId);
1032
1033 }
1034
1035 // including successes gets very verbose
1036 // but once we cut over to statsd, log them all.
1037 if (status != NO_ERROR) {
1038
1039 static constexpr char kAudioPolicy[] = "audiopolicy";
1040
1041 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
1042 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
1043 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
1044 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
1045 static constexpr char kAudioPolicyRqstDevice[] =
1046 "android.media.audiopolicy.rqst.device";
1047 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
1048 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
1049 static constexpr char kAudioPolicyActiveSession[] =
1050 "android.media.audiopolicy.active.session";
1051 static constexpr char kAudioPolicyActiveDevice[] =
1052 "android.media.audiopolicy.active.device";
1053 static constexpr char kAudioPolicyActiveDevices[] =
1054 "android.media.audiopolicy.active.devices";
1055
1056 mediametrics::Item *item = mediametrics::Item::create(kAudioPolicy);
1057 if (item != NULL) {
1058
1059 item->setInt32(kAudioPolicyStatus, status);
1060
1061 item->setCString(kAudioPolicyRqstSrc,
1062 toString(client->attributes.source).c_str());
1063 item->setInt32(kAudioPolicyRqstSession, client->session);
1064 if (client->attributionSource.packageName.has_value() &&
1065 client->attributionSource.packageName.value().size() != 0) {
1066 item->setCString(kAudioPolicyRqstPkg,
1067 client->attributionSource.packageName.value().c_str());
1068 } else {
1069 item->setCString(kAudioPolicyRqstPkg,
1070 std::to_string(client->attributionSource.uid).c_str());
1071 }
1072 item->setCString(kAudioPolicyRqstDevice,
1073 getDeviceTypeStrForPortId(getFirstDeviceId(client->deviceIds)).c_str());
1074
1075 int count = mAudioRecordClients.size();
1076 for (int i = 0; i < count ; i++) {
1077 if (portId == mAudioRecordClients.keyAt(i)) {
1078 continue;
1079 }
1080 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
1081 if (other->active) {
1082 // keeps the last of the clients marked active
1083 item->setCString(kAudioPolicyActiveSrc,
1084 toString(other->attributes.source).c_str());
1085 item->setInt32(kAudioPolicyActiveSession, other->session);
1086 if (other->attributionSource.packageName.has_value() &&
1087 other->attributionSource.packageName.value().size() != 0) {
1088 item->setCString(kAudioPolicyActivePkg,
1089 other->attributionSource.packageName.value().c_str());
1090 } else {
1091 item->setCString(kAudioPolicyRqstPkg, std::to_string(
1092 other->attributionSource.uid).c_str());
1093 }
1094 item->setCString(kAudioPolicyActiveDevice,
1095 getDeviceTypeStrForPortId(getFirstDeviceId(other->deviceIds)).c_str());
1096 item->setCString(kAudioPolicyActiveDevices,
1097 getDeviceTypeStrForPortIds(other->deviceIds).c_str());
1098 }
1099 }
1100 item->selfrecord();
1101 delete item;
1102 item = NULL;
1103 }
1104 }
1105
1106 if (status != NO_ERROR) {
1107 client->active = false;
1108 client->startTimeNs = 0;
1109 updateUidStates_l();
1110 if (!client->silenced) {
1111 finishRecording(client->attributionSource, client->virtualDeviceId,
1112 client->attributes.source);
1113 }
1114 }
1115
1116 return binderStatusFromStatusT(status);
1117 }
1118
stopInput(int32_t portIdAidl)1119 Status AudioPolicyService::stopInput(int32_t portIdAidl)
1120 {
1121 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
1122 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
1123
1124 if (mAudioPolicyManager == NULL) {
1125 return binderStatusFromStatusT(NO_INIT);
1126 }
1127
1128 audio_utils::lock_guard _l(mMutex);
1129
1130 ssize_t index = mAudioRecordClients.indexOfKey(portId);
1131 if (index < 0) {
1132 return binderStatusFromStatusT(INVALID_OPERATION);
1133 }
1134 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
1135
1136 client->active = false;
1137 client->startTimeNs = 0;
1138
1139 updateUidStates_l();
1140
1141 // finish the recording app op
1142 if (!client->silenced) {
1143 finishRecording(client->attributionSource, client->virtualDeviceId,
1144 client->attributes.source);
1145 }
1146
1147 AutoCallerClear acc;
1148 return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
1149 }
1150
releaseInput(int32_t portIdAidl)1151 Status AudioPolicyService::releaseInput(int32_t portIdAidl)
1152 {
1153 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
1154 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
1155
1156 if (mAudioPolicyManager == NULL) {
1157 return binderStatusFromStatusT(NO_INIT);
1158 }
1159 sp<AudioPolicyEffects>audioPolicyEffects;
1160 sp<AudioRecordClient> client;
1161 {
1162 audio_utils::lock_guard _l(mMutex);
1163 audioPolicyEffects = mAudioPolicyEffects;
1164 ssize_t index = mAudioRecordClients.indexOfKey(portId);
1165 if (index < 0) {
1166 return Status::ok();
1167 }
1168 client = mAudioRecordClients.valueAt(index);
1169
1170 if (client->active) {
1171 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
1172 client->active = false;
1173 client->startTimeNs = 0;
1174 updateUidStates_l();
1175 }
1176
1177 mAudioRecordClients.removeItem(portId);
1178 }
1179 if (client == 0) {
1180 return Status::ok();
1181 }
1182 if (audioPolicyEffects != 0) {
1183 // release audio processors from the input
1184 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
1185 if(status != NO_ERROR) {
1186 ALOGW("Failed to release effects on input %d", client->io);
1187 }
1188 }
1189 {
1190 audio_utils::lock_guard _l(mMutex);
1191 AutoCallerClear acc;
1192 mAudioPolicyManager->releaseInput(portId);
1193 }
1194 return Status::ok();
1195 }
1196
setDeviceAbsoluteVolumeEnabled(const AudioDevice & deviceAidl,bool enabled,AudioStreamType streamToDriveAbsAidl)1197 Status AudioPolicyService::setDeviceAbsoluteVolumeEnabled(const AudioDevice& deviceAidl,
1198 bool enabled,
1199 AudioStreamType streamToDriveAbsAidl) {
1200 ALOGI("%s: deviceAidl %s, enabled %d, streamToDriveAbsAidl %d", __func__,
1201 deviceAidl.toString().c_str(), enabled, streamToDriveAbsAidl);
1202
1203 audio_stream_type_t streamToDriveAbs = AUDIO_STREAM_DEFAULT;
1204 if (enabled) {
1205 streamToDriveAbs = VALUE_OR_RETURN_BINDER_STATUS(
1206 aidl2legacy_AudioStreamType_audio_stream_type_t(streamToDriveAbsAidl));
1207 }
1208
1209 audio_devices_t deviceType;
1210 std::string address;
1211 RETURN_BINDER_STATUS_IF_ERROR(
1212 aidl2legacy_AudioDevice_audio_device(deviceAidl, &deviceType, &address));
1213
1214 if (mAudioPolicyManager == nullptr) {
1215 return binderStatusFromStatusT(NO_INIT);
1216 }
1217 if (!(audioserver_permissions() ?
1218 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1219 : settingsAllowed())) {
1220 return binderStatusFromStatusT(PERMISSION_DENIED);
1221 }
1222
1223 audio_utils::lock_guard _l(mMutex);
1224 AutoCallerClear acc;
1225 return binderStatusFromStatusT(
1226 mAudioPolicyManager->setDeviceAbsoluteVolumeEnabled(deviceType, address.c_str(),
1227 enabled, streamToDriveAbs));
1228 }
1229
initStreamVolume(AudioStreamType streamAidl,int32_t indexMinAidl,int32_t indexMaxAidl)1230 Status AudioPolicyService::initStreamVolume(AudioStreamType streamAidl,
1231 int32_t indexMinAidl,
1232 int32_t indexMaxAidl) {
1233 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1234 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1235 int indexMin = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMinAidl));
1236 int indexMax = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMaxAidl));
1237
1238 if (mAudioPolicyManager == NULL) {
1239 return binderStatusFromStatusT(NO_INIT);
1240 }
1241 if (!(audioserver_permissions() ?
1242 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1243 : settingsAllowed())) {
1244 return binderStatusFromStatusT(PERMISSION_DENIED);
1245 }
1246 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1247 return binderStatusFromStatusT(BAD_VALUE);
1248 }
1249 audio_utils::lock_guard _l(mMutex);
1250 AutoCallerClear acc;
1251 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
1252 return binderStatusFromStatusT(NO_ERROR);
1253 }
1254
setStreamVolumeIndex(AudioStreamType streamAidl,const AudioDeviceDescription & deviceAidl,int32_t indexAidl,bool muted)1255 Status AudioPolicyService::setStreamVolumeIndex(AudioStreamType streamAidl,
1256 const AudioDeviceDescription& deviceAidl,
1257 int32_t indexAidl, bool muted) {
1258 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1259 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1260 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
1261 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1262 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
1263
1264 if (mAudioPolicyManager == NULL) {
1265 return binderStatusFromStatusT(NO_INIT);
1266 }
1267 if (!(audioserver_permissions() ?
1268 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1269 : settingsAllowed())) {
1270 return binderStatusFromStatusT(PERMISSION_DENIED);
1271 }
1272 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1273 return binderStatusFromStatusT(BAD_VALUE);
1274 }
1275 audio_utils::lock_guard _l(mMutex);
1276 AutoCallerClear acc;
1277 return binderStatusFromStatusT(mAudioPolicyManager->setStreamVolumeIndex(stream,
1278 index,
1279 muted,
1280 device));
1281 }
1282
getStreamVolumeIndex(AudioStreamType streamAidl,const AudioDeviceDescription & deviceAidl,int32_t * _aidl_return)1283 Status AudioPolicyService::getStreamVolumeIndex(AudioStreamType streamAidl,
1284 const AudioDeviceDescription& deviceAidl,
1285 int32_t* _aidl_return) {
1286 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1287 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1288 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1289 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
1290 int index;
1291
1292 if (mAudioPolicyManager == NULL) {
1293 return binderStatusFromStatusT(NO_INIT);
1294 }
1295 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1296 return binderStatusFromStatusT(BAD_VALUE);
1297 }
1298 audio_utils::lock_guard _l(mMutex);
1299 AutoCallerClear acc;
1300 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1301 mAudioPolicyManager->getStreamVolumeIndex(stream, &index, device)));
1302 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1303 return Status::ok();
1304 }
1305
setVolumeIndexForAttributes(const media::audio::common::AudioAttributes & attrAidl,const AudioDeviceDescription & deviceAidl,int32_t indexAidl,bool muted)1306 Status AudioPolicyService::setVolumeIndexForAttributes(
1307 const media::audio::common::AudioAttributes& attrAidl,
1308 const AudioDeviceDescription& deviceAidl, int32_t indexAidl, bool muted) {
1309 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1310 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
1311 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
1312 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1313 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
1314 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1315 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1316
1317 if (mAudioPolicyManager == NULL) {
1318 return binderStatusFromStatusT(NO_INIT);
1319 }
1320 if (!(audioserver_permissions() ?
1321 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
1322 : settingsAllowed())) {
1323 return binderStatusFromStatusT(PERMISSION_DENIED);
1324 }
1325 audio_utils::lock_guard _l(mMutex);
1326 AutoCallerClear acc;
1327 return binderStatusFromStatusT(
1328 mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, muted, device));
1329 }
1330
getVolumeIndexForAttributes(const media::audio::common::AudioAttributes & attrAidl,const AudioDeviceDescription & deviceAidl,int32_t * _aidl_return)1331 Status AudioPolicyService::getVolumeIndexForAttributes(
1332 const media::audio::common::AudioAttributes& attrAidl,
1333 const AudioDeviceDescription& deviceAidl, int32_t* _aidl_return) {
1334 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1335 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
1336 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1337 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
1338 int index;
1339 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1340 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1341
1342 if (mAudioPolicyManager == NULL) {
1343 return binderStatusFromStatusT(NO_INIT);
1344 }
1345 audio_utils::lock_guard _l(mMutex);
1346 AutoCallerClear acc;
1347 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1348 mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device)));
1349 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1350 return Status::ok();
1351 }
1352
getMinVolumeIndexForAttributes(const media::audio::common::AudioAttributes & attrAidl,int32_t * _aidl_return)1353 Status AudioPolicyService::getMinVolumeIndexForAttributes(
1354 const media::audio::common::AudioAttributes& attrAidl, int32_t* _aidl_return) {
1355 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1356 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
1357 int index;
1358 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1359 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1360
1361 if (mAudioPolicyManager == NULL) {
1362 return binderStatusFromStatusT(NO_INIT);
1363 }
1364 audio_utils::lock_guard _l(mMutex);
1365 AutoCallerClear acc;
1366 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1367 mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index)));
1368 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1369 return Status::ok();
1370 }
1371
getMaxVolumeIndexForAttributes(const media::audio::common::AudioAttributes & attrAidl,int32_t * _aidl_return)1372 Status AudioPolicyService::getMaxVolumeIndexForAttributes(
1373 const media::audio::common::AudioAttributes& attrAidl, int32_t* _aidl_return) {
1374 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1375 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
1376 int index;
1377 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1378 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1379
1380 if (mAudioPolicyManager == NULL) {
1381 return binderStatusFromStatusT(NO_INIT);
1382 }
1383 audio_utils::lock_guard _l(mMutex);
1384 AutoCallerClear acc;
1385 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1386 mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index)));
1387 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1388 return Status::ok();
1389 }
1390
getStrategyForStream(AudioStreamType streamAidl,int32_t * _aidl_return)1391 Status AudioPolicyService::getStrategyForStream(AudioStreamType streamAidl,
1392 int32_t* _aidl_return) {
1393 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1394 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1395
1396 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1397 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1398 convertReinterpret<int32_t>(PRODUCT_STRATEGY_NONE));
1399 return Status::ok();
1400 }
1401 if (mAudioPolicyManager == NULL) {
1402 return binderStatusFromStatusT(NO_INIT);
1403 }
1404
1405 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
1406 AutoCallerClear acc;
1407 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1408 legacy2aidl_product_strategy_t_int32_t(
1409 mAudioPolicyManager->getStrategyForStream(stream)));
1410 return Status::ok();
1411 }
1412
getDevicesForAttributes(const media::audio::common::AudioAttributes & attrAidl,bool forVolume,std::vector<AudioDevice> * _aidl_return)1413 Status AudioPolicyService::getDevicesForAttributes(
1414 const media::audio::common::AudioAttributes& attrAidl,
1415 bool forVolume,
1416 std::vector<AudioDevice>* _aidl_return)
1417 {
1418 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
1419 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
1420 AudioDeviceTypeAddrVector devices;
1421
1422 if (mAudioPolicyManager == NULL) {
1423 return binderStatusFromStatusT(NO_INIT);
1424 }
1425 audio_utils::lock_guard _l(mMutex);
1426 AutoCallerClear acc;
1427 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1428 mAudioPolicyManager->getDevicesForAttributes(aa, &devices, forVolume)));
1429 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1430 convertContainer<std::vector<AudioDevice>>(devices,
1431 legacy2aidl_AudioDeviceTypeAddress));
1432 return Status::ok();
1433 }
1434
getOutputForEffect(const media::EffectDescriptor & descAidl,int32_t * _aidl_return)1435 Status AudioPolicyService::getOutputForEffect(const media::EffectDescriptor& descAidl,
1436 int32_t* _aidl_return) {
1437 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1438 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1439 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1440 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1441
1442 if (mAudioPolicyManager == NULL) {
1443 return binderStatusFromStatusT(NO_INIT);
1444 }
1445 audio_utils::lock_guard _l(mMutex);
1446 AutoCallerClear acc;
1447 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1448 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutputForEffect(&desc)));
1449 return Status::ok();
1450 }
1451
registerEffect(const media::EffectDescriptor & descAidl,int32_t ioAidl,int32_t strategyAidl,int32_t sessionAidl,int32_t idAidl)1452 Status AudioPolicyService::registerEffect(const media::EffectDescriptor& descAidl, int32_t ioAidl,
1453 int32_t strategyAidl, int32_t sessionAidl,
1454 int32_t idAidl) {
1455 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1456 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1457 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1458 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1459 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
1460 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
1461 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
1462 aidl2legacy_int32_t_audio_session_t(sessionAidl));
1463 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1464 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1465 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1466
1467 if (mAudioPolicyManager == NULL) {
1468 return binderStatusFromStatusT(NO_INIT);
1469 }
1470 audio_utils::lock_guard _l(mMutex);
1471 AutoCallerClear acc;
1472 return binderStatusFromStatusT(
1473 mAudioPolicyManager->registerEffect(&desc, io, strategy, session, id));
1474 }
1475
unregisterEffect(int32_t idAidl)1476 Status AudioPolicyService::unregisterEffect(int32_t idAidl)
1477 {
1478 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1479 if (mAudioPolicyManager == NULL) {
1480 return binderStatusFromStatusT(NO_INIT);
1481 }
1482 audio_utils::lock_guard _l(mMutex);
1483 AutoCallerClear acc;
1484 return binderStatusFromStatusT(mAudioPolicyManager->unregisterEffect(id));
1485 }
1486
setEffectEnabled(int32_t idAidl,bool enabled)1487 Status AudioPolicyService::setEffectEnabled(int32_t idAidl, bool enabled)
1488 {
1489 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1490 if (mAudioPolicyManager == NULL) {
1491 return binderStatusFromStatusT(NO_INIT);
1492 }
1493 audio_utils::lock_guard _l(mMutex);
1494 AutoCallerClear acc;
1495 return binderStatusFromStatusT(mAudioPolicyManager->setEffectEnabled(id, enabled));
1496 }
1497
moveEffectsToIo(const std::vector<int32_t> & idsAidl,int32_t ioAidl)1498 Status AudioPolicyService::moveEffectsToIo(const std::vector<int32_t>& idsAidl, int32_t ioAidl)
1499
1500 {
1501 const std::vector<int>& ids = VALUE_OR_RETURN_BINDER_STATUS(
1502 convertContainer<std::vector<int>>(idsAidl, convertReinterpret<int, int32_t>));
1503 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1504 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1505 if (ids.size() > MAX_ITEMS_PER_LIST) {
1506 return binderStatusFromStatusT(BAD_VALUE);
1507 }
1508
1509 if (mAudioPolicyManager == NULL) {
1510 return binderStatusFromStatusT(NO_INIT);
1511 }
1512 audio_utils::lock_guard _l(mMutex);
1513 AutoCallerClear acc;
1514 return binderStatusFromStatusT(mAudioPolicyManager->moveEffectsToIo(ids, io));
1515 }
1516
isStreamActive(AudioStreamType streamAidl,int32_t inPastMsAidl,bool * _aidl_return)1517 Status AudioPolicyService::isStreamActive(AudioStreamType streamAidl, int32_t inPastMsAidl,
1518 bool* _aidl_return) {
1519 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1520 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1521 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1522
1523 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1524 *_aidl_return = false;
1525 return Status::ok();
1526 }
1527 if (mAudioPolicyManager == NULL) {
1528 return binderStatusFromStatusT(NO_INIT);
1529 }
1530 audio_utils::lock_guard _l(mMutex);
1531 AutoCallerClear acc;
1532 *_aidl_return = mAudioPolicyManager->isStreamActive(stream, inPastMs);
1533 return Status::ok();
1534 }
1535
isStreamActiveRemotely(AudioStreamType streamAidl,int32_t inPastMsAidl,bool * _aidl_return)1536 Status AudioPolicyService::isStreamActiveRemotely(AudioStreamType streamAidl,
1537 int32_t inPastMsAidl,
1538 bool* _aidl_return) {
1539 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1540 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1541 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1542
1543 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1544 *_aidl_return = false;
1545 return Status::ok();
1546 }
1547 if (mAudioPolicyManager == NULL) {
1548 return binderStatusFromStatusT(NO_INIT);
1549 }
1550 audio_utils::lock_guard _l(mMutex);
1551 AutoCallerClear acc;
1552 *_aidl_return = mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
1553 return Status::ok();
1554 }
1555
isSourceActive(AudioSource sourceAidl,bool * _aidl_return)1556 Status AudioPolicyService::isSourceActive(AudioSource sourceAidl, bool* _aidl_return) {
1557 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
1558 aidl2legacy_AudioSource_audio_source_t(sourceAidl));
1559 if (mAudioPolicyManager == NULL) {
1560 return binderStatusFromStatusT(NO_INIT);
1561 }
1562 audio_utils::lock_guard _l(mMutex);
1563 AutoCallerClear acc;
1564 *_aidl_return = mAudioPolicyManager->isSourceActive(source);
1565 return Status::ok();
1566 }
1567
getAudioPolicyEffects(sp<AudioPolicyEffects> & audioPolicyEffects)1568 status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
1569 {
1570 if (mAudioPolicyManager == NULL) {
1571 return NO_INIT;
1572 }
1573 {
1574 audio_utils::lock_guard _l(mMutex);
1575 audioPolicyEffects = mAudioPolicyEffects;
1576 }
1577 if (audioPolicyEffects == 0) {
1578 return NO_INIT;
1579 }
1580
1581 return OK;
1582 }
1583
queryDefaultPreProcessing(int32_t audioSessionAidl,Int * countAidl,std::vector<media::EffectDescriptor> * _aidl_return)1584 Status AudioPolicyService::queryDefaultPreProcessing(
1585 int32_t audioSessionAidl,
1586 Int* countAidl,
1587 std::vector<media::EffectDescriptor>* _aidl_return) {
1588 audio_session_t audioSession = VALUE_OR_RETURN_BINDER_STATUS(
1589 aidl2legacy_int32_t_audio_session_t(audioSessionAidl));
1590 uint32_t count = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(countAidl->value));
1591 if (count > AudioEffect::kMaxPreProcessing) {
1592 count = AudioEffect::kMaxPreProcessing;
1593 }
1594 uint32_t countReq = count;
1595 std::unique_ptr<effect_descriptor_t[]> descriptors(new effect_descriptor_t[count]);
1596
1597 sp<AudioPolicyEffects> audioPolicyEffects;
1598 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1599 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->queryDefaultInputEffects(
1600 (audio_session_t) audioSession, descriptors.get(), &count)));
1601 countReq = std::min(count, countReq);
1602 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1603 convertRange(descriptors.get(), descriptors.get() + countReq,
1604 std::back_inserter(*_aidl_return),
1605 legacy2aidl_effect_descriptor_t_EffectDescriptor)));
1606 countAidl->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(count));
1607 return Status::ok();
1608 }
1609
addSourceDefaultEffect(const AudioUuid & typeAidl,const std::string & opPackageNameAidl,const AudioUuid & uuidAidl,int32_t priority,AudioSource sourceAidl,int32_t * _aidl_return)1610 Status AudioPolicyService::addSourceDefaultEffect(const AudioUuid& typeAidl,
1611 const std::string& opPackageNameAidl,
1612 const AudioUuid& uuidAidl,
1613 int32_t priority,
1614 AudioSource sourceAidl,
1615 int32_t* _aidl_return) {
1616 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1617 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1618 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1619 aidl2legacy_string_view_String16(opPackageNameAidl));
1620 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1621 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1622 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
1623 aidl2legacy_AudioSource_audio_source_t(sourceAidl));
1624 audio_unique_id_t id;
1625
1626 sp<AudioPolicyEffects>audioPolicyEffects;
1627 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1628 if (!(audioserver_permissions() ?
1629 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1630 : modifyDefaultAudioEffectsAllowed())) {
1631 return binderStatusFromStatusT(PERMISSION_DENIED);
1632 }
1633 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addSourceDefaultEffect(
1634 &type, opPackageName, &uuid, priority, source, &id)));
1635 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1636 return Status::ok();
1637 }
1638
addStreamDefaultEffect(const AudioUuid & typeAidl,const std::string & opPackageNameAidl,const AudioUuid & uuidAidl,int32_t priority,AudioUsage usageAidl,int32_t * _aidl_return)1639 Status AudioPolicyService::addStreamDefaultEffect(const AudioUuid& typeAidl,
1640 const std::string& opPackageNameAidl,
1641 const AudioUuid& uuidAidl,
1642 int32_t priority, AudioUsage usageAidl,
1643 int32_t* _aidl_return) {
1644 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1645 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1646 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1647 aidl2legacy_string_view_String16(opPackageNameAidl));
1648 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1649 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1650 audio_usage_t usage = VALUE_OR_RETURN_BINDER_STATUS(
1651 aidl2legacy_AudioUsage_audio_usage_t(usageAidl));
1652 audio_unique_id_t id;
1653
1654 sp<AudioPolicyEffects> audioPolicyEffects;
1655 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1656 if (!(audioserver_permissions() ?
1657 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1658 : modifyDefaultAudioEffectsAllowed())) {
1659 return binderStatusFromStatusT(PERMISSION_DENIED);
1660 }
1661 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addStreamDefaultEffect(
1662 &type, opPackageName, &uuid, priority, usage, &id)));
1663 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1664 return Status::ok();
1665 }
1666
removeSourceDefaultEffect(int32_t idAidl)1667 Status AudioPolicyService::removeSourceDefaultEffect(int32_t idAidl)
1668 {
1669 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1670 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
1671 sp<AudioPolicyEffects>audioPolicyEffects;
1672 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1673 if (!(audioserver_permissions() ?
1674 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1675 : modifyDefaultAudioEffectsAllowed())) {
1676 return binderStatusFromStatusT(PERMISSION_DENIED);
1677 }
1678 return binderStatusFromStatusT(audioPolicyEffects->removeSourceDefaultEffect(id));
1679 }
1680
removeStreamDefaultEffect(int32_t idAidl)1681 Status AudioPolicyService::removeStreamDefaultEffect(int32_t idAidl)
1682 {
1683 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1684 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
1685 sp<AudioPolicyEffects>audioPolicyEffects;
1686 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1687 if (!(audioserver_permissions() ?
1688 CHECK_PERM(MODIFY_DEFAULT_AUDIO_EFFECTS, IPCThreadState::self()->getCallingUid())
1689 : modifyDefaultAudioEffectsAllowed())) {
1690 return binderStatusFromStatusT(PERMISSION_DENIED);
1691 }
1692 return binderStatusFromStatusT(audioPolicyEffects->removeStreamDefaultEffect(id));
1693 }
1694
setSupportedSystemUsages(const std::vector<AudioUsage> & systemUsagesAidl)1695 Status AudioPolicyService::setSupportedSystemUsages(
1696 const std::vector<AudioUsage>& systemUsagesAidl) {
1697 size_t size = systemUsagesAidl.size();
1698 if (size > MAX_ITEMS_PER_LIST) {
1699 size = MAX_ITEMS_PER_LIST;
1700 }
1701 std::vector<audio_usage_t> systemUsages;
1702 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1703 convertRange(systemUsagesAidl.begin(), systemUsagesAidl.begin() + size,
1704 std::back_inserter(systemUsages), aidl2legacy_AudioUsage_audio_usage_t)));
1705
1706 audio_utils::lock_guard _l(mMutex);
1707 if (!(audioserver_permissions() ?
1708 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1709 : modifyAudioRoutingAllowed())) {
1710 return binderStatusFromStatusT(PERMISSION_DENIED);
1711 }
1712
1713 bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
1714 [](audio_usage_t usage) { return isSystemUsage(usage); });
1715 if (!areAllSystemUsages) {
1716 return binderStatusFromStatusT(BAD_VALUE);
1717 }
1718
1719 mSupportedSystemUsages = systemUsages;
1720 return Status::ok();
1721 }
1722
setAllowedCapturePolicy(int32_t uidAidl,int32_t capturePolicyAidl)1723 Status AudioPolicyService::setAllowedCapturePolicy(int32_t uidAidl, int32_t capturePolicyAidl) {
1724 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1725 audio_flags_mask_t capturePolicy = VALUE_OR_RETURN_BINDER_STATUS(
1726 aidl2legacy_int32_t_audio_flags_mask_t_mask(capturePolicyAidl));
1727
1728 audio_utils::lock_guard _l(mMutex);
1729 if (mAudioPolicyManager == NULL) {
1730 ALOGV("%s() mAudioPolicyManager == NULL", __func__);
1731 return binderStatusFromStatusT(NO_INIT);
1732 }
1733 return binderStatusFromStatusT(
1734 mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy));
1735 }
1736
getOffloadSupport(const AudioOffloadInfo & infoAidl,media::AudioOffloadMode * _aidl_return)1737 Status AudioPolicyService::getOffloadSupport(const AudioOffloadInfo& infoAidl,
1738 media::AudioOffloadMode* _aidl_return) {
1739 audio_offload_info_t info = VALUE_OR_RETURN_BINDER_STATUS(
1740 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(infoAidl));
1741 if (mAudioPolicyManager == NULL) {
1742 ALOGV("mAudioPolicyManager == NULL");
1743 return binderStatusFromStatusT(AUDIO_OFFLOAD_NOT_SUPPORTED);
1744 }
1745 audio_utils::lock_guard _l(mMutex);
1746 AutoCallerClear acc;
1747 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_offload_mode_t_AudioOffloadMode(
1748 mAudioPolicyManager->getOffloadSupport(info)));
1749 return Status::ok();
1750 }
1751
isDirectOutputSupported(const AudioConfigBase & configAidl,const media::audio::common::AudioAttributes & attributesAidl,bool * _aidl_return)1752 Status AudioPolicyService::isDirectOutputSupported(
1753 const AudioConfigBase& configAidl,
1754 const media::audio::common::AudioAttributes& attributesAidl,
1755 bool* _aidl_return) {
1756 audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
1757 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl, false /*isInput*/));
1758 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1759 aidl2legacy_AudioAttributes_audio_attributes_t(attributesAidl));
1760 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1761 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1762
1763 if (mAudioPolicyManager == NULL) {
1764 ALOGV("mAudioPolicyManager == NULL");
1765 return binderStatusFromStatusT(NO_INIT);
1766 }
1767
1768 RETURN_IF_BINDER_ERROR(validateUsage(attributes));
1769
1770 audio_utils::lock_guard _l(mMutex);
1771 *_aidl_return = mAudioPolicyManager->isDirectOutputSupported(config, attributes);
1772 return Status::ok();
1773 }
1774
1775 template <typename Port>
anonymizePortBluetoothAddress(Port & port)1776 void anonymizePortBluetoothAddress(Port& port) {
1777 if (port.type != AUDIO_PORT_TYPE_DEVICE) {
1778 return;
1779 }
1780 if (!(audio_is_a2dp_device(port.ext.device.type)
1781 || audio_is_ble_device(port.ext.device.type)
1782 || audio_is_bluetooth_sco_device(port.ext.device.type)
1783 || audio_is_hearing_aid_out_device(port.ext.device.type))) {
1784 return;
1785 }
1786 anonymizeBluetoothAddress(port.ext.device.address);
1787 }
1788
listAudioPorts(media::AudioPortRole roleAidl,media::AudioPortType typeAidl,Int * count,std::vector<media::AudioPortFw> * portsAidl,int32_t * _aidl_return)1789 Status AudioPolicyService::listAudioPorts(media::AudioPortRole roleAidl,
1790 media::AudioPortType typeAidl, Int* count,
1791 std::vector<media::AudioPortFw>* portsAidl,
1792 int32_t* _aidl_return) {
1793 audio_port_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
1794 aidl2legacy_AudioPortRole_audio_port_role_t(roleAidl));
1795 audio_port_type_t type = VALUE_OR_RETURN_BINDER_STATUS(
1796 aidl2legacy_AudioPortType_audio_port_type_t(typeAidl));
1797 unsigned int num_ports = VALUE_OR_RETURN_BINDER_STATUS(
1798 convertIntegral<unsigned int>(count->value));
1799 if (num_ports > MAX_ITEMS_PER_LIST) {
1800 num_ports = MAX_ITEMS_PER_LIST;
1801 }
1802 unsigned int numPortsReq = num_ports;
1803 std::unique_ptr<audio_port_v7[]> ports(new audio_port_v7[num_ports]);
1804 unsigned int generation;
1805
1806 const AttributionSourceState attributionSource = getCallingAttributionSource();
1807 AutoCallerClear acc;
1808 {
1809 audio_utils::lock_guard _l(mMutex);
1810 if (mAudioPolicyManager == NULL) {
1811 return binderStatusFromStatusT(NO_INIT);
1812 }
1813 // AudioPolicyManager->listAudioPorts makes a deep copy of port structs into ports
1814 // so it is safe to access after releasing the mutex
1815 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1816 mAudioPolicyManager->listAudioPorts(
1817 role, type, &num_ports, ports.get(), &generation)));
1818 numPortsReq = std::min(numPortsReq, num_ports);
1819 }
1820
1821 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__),
1822 getPermissionProvider())) {
1823 for (size_t i = 0; i < numPortsReq; ++i) {
1824 anonymizePortBluetoothAddress(ports[i]);
1825 }
1826 }
1827
1828 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1829 convertRange(ports.get(), ports.get() + numPortsReq, std::back_inserter(*portsAidl),
1830 legacy2aidl_audio_port_v7_AudioPortFw)));
1831 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_ports));
1832 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1833 return Status::ok();
1834 }
1835
listDeclaredDevicePorts(media::AudioPortRole role,std::vector<media::AudioPortFw> * _aidl_return)1836 Status AudioPolicyService::listDeclaredDevicePorts(media::AudioPortRole role,
1837 std::vector<media::AudioPortFw>* _aidl_return) {
1838 audio_utils::lock_guard _l(mMutex);
1839 if (mAudioPolicyManager == NULL) {
1840 return binderStatusFromStatusT(NO_INIT);
1841 }
1842 AutoCallerClear acc;
1843 return binderStatusFromStatusT(mAudioPolicyManager->listDeclaredDevicePorts(
1844 role, _aidl_return));
1845 }
1846
getAudioPort(int portId,media::AudioPortFw * _aidl_return)1847 Status AudioPolicyService::getAudioPort(int portId,
1848 media::AudioPortFw* _aidl_return) {
1849 audio_port_v7 port{ .id = portId };
1850
1851 const AttributionSourceState attributionSource = getCallingAttributionSource();
1852 AutoCallerClear acc;
1853
1854 {
1855 audio_utils::lock_guard _l(mMutex);
1856 if (mAudioPolicyManager == NULL) {
1857 return binderStatusFromStatusT(NO_INIT);
1858 }
1859 // AudioPolicyManager->getAudioPort makes a deep copy of the port struct into port
1860 // so it is safe to access after releasing the mutex
1861 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(mAudioPolicyManager->getAudioPort(&port)));
1862 }
1863
1864 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__),
1865 getPermissionProvider())) {
1866 anonymizePortBluetoothAddress(port);
1867 }
1868
1869 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_v7_AudioPortFw(port));
1870 return Status::ok();
1871 }
1872
createAudioPatch(const media::AudioPatchFw & patchAidl,int32_t handleAidl,int32_t * _aidl_return)1873 Status AudioPolicyService::createAudioPatch(const media::AudioPatchFw& patchAidl,
1874 int32_t handleAidl,
1875 int32_t* _aidl_return) {
1876 audio_patch patch = VALUE_OR_RETURN_BINDER_STATUS(
1877 aidl2legacy_AudioPatchFw_audio_patch(patchAidl));
1878 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1879 aidl2legacy_int32_t_audio_port_handle_t(handleAidl));
1880 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPatch(patch)));
1881
1882 audio_utils::lock_guard _l(mMutex);
1883 if (!(audioserver_permissions() ?
1884 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1885 : modifyAudioRoutingAllowed())) {
1886 return binderStatusFromStatusT(PERMISSION_DENIED);
1887 }
1888 if (mAudioPolicyManager == NULL) {
1889 return binderStatusFromStatusT(NO_INIT);
1890 }
1891 AutoCallerClear acc;
1892 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1893 mAudioPolicyManager->createAudioPatch(&patch, &handle,
1894 IPCThreadState::self()->getCallingUid())));
1895 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
1896 return Status::ok();
1897 }
1898
releaseAudioPatch(int32_t handleAidl)1899 Status AudioPolicyService::releaseAudioPatch(int32_t handleAidl)
1900 {
1901 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1902 aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
1903 audio_utils::lock_guard _l(mMutex);
1904 if (!(audioserver_permissions() ?
1905 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1906 : modifyAudioRoutingAllowed())) {
1907 return binderStatusFromStatusT(PERMISSION_DENIED);
1908 }
1909 if (mAudioPolicyManager == NULL) {
1910 return binderStatusFromStatusT(NO_INIT);
1911 }
1912 AutoCallerClear acc;
1913 return binderStatusFromStatusT(
1914 mAudioPolicyManager->releaseAudioPatch(handle,
1915 IPCThreadState::self()->getCallingUid()));
1916 }
1917
listAudioPatches(Int * count,std::vector<media::AudioPatchFw> * patchesAidl,int32_t * _aidl_return)1918 Status AudioPolicyService::listAudioPatches(Int* count,
1919 std::vector<media::AudioPatchFw>* patchesAidl,
1920 int32_t* _aidl_return) {
1921 unsigned int num_patches = VALUE_OR_RETURN_BINDER_STATUS(
1922 convertIntegral<unsigned int>(count->value));
1923 if (num_patches > MAX_ITEMS_PER_LIST) {
1924 num_patches = MAX_ITEMS_PER_LIST;
1925 }
1926 unsigned int numPatchesReq = num_patches;
1927 std::unique_ptr<audio_patch[]> patches(new audio_patch[num_patches]);
1928 unsigned int generation;
1929
1930 const AttributionSourceState attributionSource = getCallingAttributionSource();
1931 AutoCallerClear acc;
1932
1933 {
1934 audio_utils::lock_guard _l(mMutex);
1935 if (mAudioPolicyManager == NULL) {
1936 return binderStatusFromStatusT(NO_INIT);
1937 }
1938 // AudioPolicyManager->listAudioPatches makes a deep copy of patches structs into patches
1939 // so it is safe to access after releasing the mutex
1940 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1941 mAudioPolicyManager->listAudioPatches(&num_patches, patches.get(), &generation)));
1942 numPatchesReq = std::min(numPatchesReq, num_patches);
1943 }
1944
1945 if (mustAnonymizeBluetoothAddress(attributionSource, String16(__func__),
1946 getPermissionProvider())) {
1947 for (size_t i = 0; i < numPatchesReq; ++i) {
1948 for (size_t j = 0; j < patches[i].num_sources; ++j) {
1949 anonymizePortBluetoothAddress(patches[i].sources[j]);
1950 }
1951 for (size_t j = 0; j < patches[i].num_sinks; ++j) {
1952 anonymizePortBluetoothAddress(patches[i].sinks[j]);
1953 }
1954 }
1955 }
1956
1957 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1958 convertRange(patches.get(), patches.get() + numPatchesReq,
1959 std::back_inserter(*patchesAidl), legacy2aidl_audio_patch_AudioPatchFw)));
1960 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_patches));
1961 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1962 return Status::ok();
1963 }
1964
setAudioPortConfig(const media::AudioPortConfigFw & configAidl)1965 Status AudioPolicyService::setAudioPortConfig(const media::AudioPortConfigFw& configAidl)
1966 {
1967 audio_port_config config = VALUE_OR_RETURN_BINDER_STATUS(
1968 aidl2legacy_AudioPortConfigFw_audio_port_config(configAidl));
1969 RETURN_IF_BINDER_ERROR(
1970 binderStatusFromStatusT(AudioValidator::validateAudioPortConfig(config)));
1971
1972 audio_utils::lock_guard _l(mMutex);
1973 if (!(audioserver_permissions() ?
1974 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
1975 : modifyAudioRoutingAllowed())) {
1976 return binderStatusFromStatusT(PERMISSION_DENIED);
1977 }
1978 if (mAudioPolicyManager == NULL) {
1979 return binderStatusFromStatusT(NO_INIT);
1980 }
1981 AutoCallerClear acc;
1982 return binderStatusFromStatusT(mAudioPolicyManager->setAudioPortConfig(&config));
1983 }
1984
acquireSoundTriggerSession(media::SoundTriggerSession * _aidl_return)1985 Status AudioPolicyService::acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return)
1986 {
1987 audio_session_t session;
1988 audio_io_handle_t ioHandle;
1989 audio_devices_t device;
1990
1991 {
1992 audio_utils::lock_guard _l(mMutex);
1993 if (mAudioPolicyManager == NULL) {
1994 return binderStatusFromStatusT(NO_INIT);
1995 }
1996 AutoCallerClear acc;
1997 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1998 mAudioPolicyManager->acquireSoundTriggerSession(&session, &ioHandle, &device)));
1999 }
2000
2001 _aidl_return->session = VALUE_OR_RETURN_BINDER_STATUS(
2002 legacy2aidl_audio_session_t_int32_t(session));
2003 _aidl_return->ioHandle = VALUE_OR_RETURN_BINDER_STATUS(
2004 legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
2005 _aidl_return->device = VALUE_OR_RETURN_BINDER_STATUS(
2006 legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
2007 return Status::ok();
2008 }
2009
releaseSoundTriggerSession(int32_t sessionAidl)2010 Status AudioPolicyService::releaseSoundTriggerSession(int32_t sessionAidl)
2011 {
2012 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
2013 aidl2legacy_int32_t_audio_session_t(sessionAidl));
2014 audio_utils::lock_guard _l(mMutex);
2015 if (mAudioPolicyManager == NULL) {
2016 return binderStatusFromStatusT(NO_INIT);
2017 }
2018 AutoCallerClear acc;
2019 return binderStatusFromStatusT(mAudioPolicyManager->releaseSoundTriggerSession(session));
2020 }
2021
registerPolicyMixes(const std::vector<media::AudioMix> & mixesAidl,bool registration)2022 Status AudioPolicyService::registerPolicyMixes(const std::vector<media::AudioMix>& mixesAidl,
2023 bool registration) {
2024 size_t size = mixesAidl.size();
2025 if (size > MAX_MIXES_PER_POLICY) {
2026 size = MAX_MIXES_PER_POLICY;
2027 }
2028 Vector<AudioMix> mixes;
2029 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2030 convertRange(mixesAidl.begin(), mixesAidl.begin() + size, std::back_inserter(mixes),
2031 aidl2legacy_AudioMix)));
2032
2033 audio_utils::lock_guard _l(mMutex);
2034
2035 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
2036 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
2037 return !is_mix_loopback_render(mix.mRouteFlags); });
2038 if (needModifyAudioRouting && !(audioserver_permissions() ?
2039 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2040 : modifyAudioRoutingAllowed())) {
2041 return binderStatusFromStatusT(PERMISSION_DENIED);
2042 }
2043
2044 // If one of the mixes has needCaptureVoiceCommunicationOutput set to true, then we
2045 // need to verify that the caller still has CAPTURE_VOICE_COMMUNICATION_OUTPUT
2046 bool needCaptureVoiceCommunicationOutput =
2047 std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
2048 return mix.mVoiceCommunicationCaptureAllowed; });
2049
2050 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
2051 return mix.mAllowPrivilegedMediaPlaybackCapture; });
2052
2053 const AttributionSourceState attributionSource = getCallingAttributionSource();
2054
2055
2056 if (needCaptureMediaOutput && !(audioserver_permissions() ?
2057 CHECK_PERM(CAPTURE_MEDIA_OUTPUT, attributionSource.uid)
2058 : captureMediaOutputAllowed(attributionSource))) {
2059 return binderStatusFromStatusT(PERMISSION_DENIED);
2060 }
2061
2062 if (needCaptureVoiceCommunicationOutput &&
2063 !(audioserver_permissions() ?
2064 CHECK_PERM(CAPTURE_VOICE_COMMUNICATION_OUTPUT, attributionSource.uid)
2065 : captureVoiceCommunicationOutputAllowed(attributionSource))) {
2066 return binderStatusFromStatusT(PERMISSION_DENIED);
2067 }
2068
2069 if (mAudioPolicyManager == NULL) {
2070 return binderStatusFromStatusT(NO_INIT);
2071 }
2072 AutoCallerClear acc;
2073 if (registration) {
2074 return binderStatusFromStatusT(mAudioPolicyManager->registerPolicyMixes(mixes));
2075 } else {
2076 return binderStatusFromStatusT(mAudioPolicyManager->unregisterPolicyMixes(mixes));
2077 }
2078 }
2079
2080 Status
getRegisteredPolicyMixes(std::vector<::android::media::AudioMix> * mixesAidl)2081 AudioPolicyService::getRegisteredPolicyMixes(std::vector<::android::media::AudioMix>* mixesAidl) {
2082 if (mAudioPolicyManager == nullptr) {
2083 return binderStatusFromStatusT(NO_INIT);
2084 }
2085
2086 std::vector<AudioMix> mixes;
2087 int status = mAudioPolicyManager->getRegisteredPolicyMixes(mixes);
2088
2089 for (const auto& mix : mixes) {
2090 media::AudioMix aidlMix = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_AudioMix(mix));
2091 mixesAidl->push_back(aidlMix);
2092 }
2093
2094 return binderStatusFromStatusT(status);
2095 }
2096
updatePolicyMixes(const::std::vector<::android::media::AudioMixUpdate> & updates)2097 Status AudioPolicyService::updatePolicyMixes(
2098 const ::std::vector<::android::media::AudioMixUpdate>& updates) {
2099 audio_utils::lock_guard _l(mMutex);
2100 for (const auto& update : updates) {
2101 AudioMix mix = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_AudioMix(update.audioMix));
2102 std::vector<AudioMixMatchCriterion> newCriteria =
2103 VALUE_OR_RETURN_BINDER_STATUS(convertContainer<std::vector<AudioMixMatchCriterion>>(
2104 update.newCriteria, aidl2legacy_AudioMixMatchCriterion));
2105 int status;
2106 if((status = mAudioPolicyManager->updatePolicyMix(mix, newCriteria)) != NO_ERROR) {
2107 return binderStatusFromStatusT(status);
2108 }
2109 }
2110 return binderStatusFromStatusT(NO_ERROR);
2111 }
2112
setUidDeviceAffinities(int32_t uidAidl,const std::vector<AudioDevice> & devicesAidl)2113 Status AudioPolicyService::setUidDeviceAffinities(
2114 int32_t uidAidl,
2115 const std::vector<AudioDevice>& devicesAidl) {
2116 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2117 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2118 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2119 aidl2legacy_AudioDeviceTypeAddress));
2120
2121 audio_utils::lock_guard _l(mMutex);
2122 if (!(audioserver_permissions() ?
2123 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2124 : modifyAudioRoutingAllowed())) {
2125 return binderStatusFromStatusT(PERMISSION_DENIED);
2126 }
2127 if (mAudioPolicyManager == NULL) {
2128 return binderStatusFromStatusT(NO_INIT);
2129 }
2130 AutoCallerClear acc;
2131 return binderStatusFromStatusT(mAudioPolicyManager->setUidDeviceAffinities(uid, devices));
2132 }
2133
removeUidDeviceAffinities(int32_t uidAidl)2134 Status AudioPolicyService::removeUidDeviceAffinities(int32_t uidAidl) {
2135 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2136
2137 audio_utils::lock_guard _l(mMutex);
2138 if (!(audioserver_permissions() ?
2139 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2140 : modifyAudioRoutingAllowed())) {
2141 return binderStatusFromStatusT(PERMISSION_DENIED);
2142 }
2143 if (mAudioPolicyManager == NULL) {
2144 return binderStatusFromStatusT(NO_INIT);
2145 }
2146 AutoCallerClear acc;
2147 return binderStatusFromStatusT(mAudioPolicyManager->removeUidDeviceAffinities(uid));
2148 }
2149
setUserIdDeviceAffinities(int32_t userIdAidl,const std::vector<AudioDevice> & devicesAidl)2150 Status AudioPolicyService::setUserIdDeviceAffinities(
2151 int32_t userIdAidl,
2152 const std::vector<AudioDevice>& devicesAidl) {
2153 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
2154 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2155 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2156 aidl2legacy_AudioDeviceTypeAddress));
2157
2158 audio_utils::lock_guard _l(mMutex);
2159 if (!(audioserver_permissions() ?
2160 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2161 : modifyAudioRoutingAllowed())) {
2162 return binderStatusFromStatusT(PERMISSION_DENIED);
2163 }
2164 if (mAudioPolicyManager == NULL) {
2165 return binderStatusFromStatusT(NO_INIT);
2166 }
2167 AutoCallerClear acc;
2168 return binderStatusFromStatusT(mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices));
2169 }
2170
removeUserIdDeviceAffinities(int32_t userIdAidl)2171 Status AudioPolicyService::removeUserIdDeviceAffinities(int32_t userIdAidl) {
2172 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
2173
2174 audio_utils::lock_guard _l(mMutex);
2175 if (!(audioserver_permissions() ?
2176 CHECK_PERM(MODIFY_AUDIO_ROUTING, IPCThreadState::self()->getCallingUid())
2177 : modifyAudioRoutingAllowed())) {
2178 return binderStatusFromStatusT(PERMISSION_DENIED);
2179 }
2180 if (mAudioPolicyManager == NULL) {
2181 return binderStatusFromStatusT(NO_INIT);
2182 }
2183 AutoCallerClear acc;
2184 return binderStatusFromStatusT(mAudioPolicyManager->removeUserIdDeviceAffinities(userId));
2185 }
2186
startAudioSource(const media::AudioPortConfigFw & sourceAidl,const media::audio::common::AudioAttributes & attributesAidl,int32_t * _aidl_return)2187 Status AudioPolicyService::startAudioSource(const media::AudioPortConfigFw& sourceAidl,
2188 const media::audio::common::AudioAttributes& attributesAidl,
2189 int32_t* _aidl_return) {
2190 audio_port_config source = VALUE_OR_RETURN_BINDER_STATUS(
2191 aidl2legacy_AudioPortConfigFw_audio_port_config(sourceAidl));
2192 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
2193 aidl2legacy_AudioAttributes_audio_attributes_t(attributesAidl));
2194 audio_port_handle_t portId;
2195 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2196 AudioValidator::validateAudioPortConfig(source)));
2197 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2198 AudioValidator::validateAudioAttributes(attributes, "68953950")));
2199
2200 audio_utils::lock_guard _l(mMutex);
2201 if (mAudioPolicyManager == NULL) {
2202 return binderStatusFromStatusT(NO_INIT);
2203 }
2204
2205 RETURN_IF_BINDER_ERROR(validateUsage(attributes));
2206
2207 // startAudioSource should be created as the calling uid
2208 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
2209 AutoCallerClear acc;
2210 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2211 mAudioPolicyManager->startAudioSource(&source, &attributes, &portId, callingUid)));
2212 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
2213 return Status::ok();
2214 }
2215
stopAudioSource(int32_t portIdAidl)2216 Status AudioPolicyService::stopAudioSource(int32_t portIdAidl)
2217 {
2218 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2219 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2220
2221 audio_utils::lock_guard _l(mMutex);
2222 if (mAudioPolicyManager == NULL) {
2223 return binderStatusFromStatusT(NO_INIT);
2224 }
2225 AutoCallerClear acc;
2226 return binderStatusFromStatusT(mAudioPolicyManager->stopAudioSource(portId));
2227 }
2228
setMasterMono(bool mono)2229 Status AudioPolicyService::setMasterMono(bool mono)
2230 {
2231 if (mAudioPolicyManager == NULL) {
2232 return binderStatusFromStatusT(NO_INIT);
2233 }
2234 if (!(audioserver_permissions() ?
2235 CHECK_PERM(MODIFY_AUDIO_SETTINGS, IPCThreadState::self()->getCallingUid())
2236 : settingsAllowed())) {
2237 return binderStatusFromStatusT(PERMISSION_DENIED);
2238 }
2239 audio_utils::lock_guard _l(mMutex);
2240 AutoCallerClear acc;
2241 return binderStatusFromStatusT(mAudioPolicyManager->setMasterMono(mono));
2242 }
2243
getMasterMono(bool * _aidl_return)2244 Status AudioPolicyService::getMasterMono(bool* _aidl_return)
2245 {
2246 if (mAudioPolicyManager == NULL) {
2247 return binderStatusFromStatusT(NO_INIT);
2248 }
2249 audio_utils::lock_guard _l(mMutex);
2250 AutoCallerClear acc;
2251 return binderStatusFromStatusT(mAudioPolicyManager->getMasterMono(_aidl_return));
2252 }
2253
2254
getStreamVolumeDB(AudioStreamType streamAidl,int32_t indexAidl,const AudioDeviceDescription & deviceAidl,float * _aidl_return)2255 Status AudioPolicyService::getStreamVolumeDB(
2256 AudioStreamType streamAidl, int32_t indexAidl,
2257 const AudioDeviceDescription& deviceAidl, float* _aidl_return) {
2258 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
2259 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
2260 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
2261 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
2262 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
2263
2264 if (mAudioPolicyManager == NULL) {
2265 return binderStatusFromStatusT(NO_INIT);
2266 }
2267 audio_utils::lock_guard _l(mMutex);
2268 AutoCallerClear acc;
2269 *_aidl_return = mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
2270 return Status::ok();
2271 }
2272
getSurroundFormats(Int * count,std::vector<AudioFormatDescription> * formats,std::vector<bool> * formatsEnabled)2273 Status AudioPolicyService::getSurroundFormats(Int* count,
2274 std::vector<AudioFormatDescription>* formats,
2275 std::vector<bool>* formatsEnabled) {
2276 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
2277 convertIntegral<unsigned int>(count->value));
2278 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
2279 numSurroundFormats = MAX_ITEMS_PER_LIST;
2280 }
2281 unsigned int numSurroundFormatsReq = numSurroundFormats;
2282 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
2283 std::unique_ptr<bool[]>surroundFormatsEnabled(new bool[numSurroundFormats]);
2284
2285 if (mAudioPolicyManager == NULL) {
2286 return binderStatusFromStatusT(NO_INIT);
2287 }
2288 audio_utils::lock_guard _l(mMutex);
2289 AutoCallerClear acc;
2290 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2291 mAudioPolicyManager->getSurroundFormats(&numSurroundFormats, surroundFormats.get(),
2292 surroundFormatsEnabled.get())));
2293 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
2294 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2295 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
2296 std::back_inserter(*formats),
2297 legacy2aidl_audio_format_t_AudioFormatDescription)));
2298 formatsEnabled->insert(
2299 formatsEnabled->begin(),
2300 surroundFormatsEnabled.get(),
2301 surroundFormatsEnabled.get() + numSurroundFormatsReq);
2302 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
2303 return Status::ok();
2304 }
2305
getReportedSurroundFormats(Int * count,std::vector<AudioFormatDescription> * formats)2306 Status AudioPolicyService::getReportedSurroundFormats(
2307 Int* count, std::vector<AudioFormatDescription>* formats) {
2308 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
2309 convertIntegral<unsigned int>(count->value));
2310 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
2311 numSurroundFormats = MAX_ITEMS_PER_LIST;
2312 }
2313 unsigned int numSurroundFormatsReq = numSurroundFormats;
2314 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
2315
2316 if (mAudioPolicyManager == NULL) {
2317 return binderStatusFromStatusT(NO_INIT);
2318 }
2319 audio_utils::lock_guard _l(mMutex);
2320 AutoCallerClear acc;
2321 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2322 mAudioPolicyManager->getReportedSurroundFormats(
2323 &numSurroundFormats, surroundFormats.get())));
2324 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
2325 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2326 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
2327 std::back_inserter(*formats),
2328 legacy2aidl_audio_format_t_AudioFormatDescription)));
2329 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
2330 return Status::ok();
2331 }
2332
getHwOffloadFormatsSupportedForBluetoothMedia(const AudioDeviceDescription & deviceAidl,std::vector<AudioFormatDescription> * _aidl_return)2333 Status AudioPolicyService::getHwOffloadFormatsSupportedForBluetoothMedia(
2334 const AudioDeviceDescription& deviceAidl,
2335 std::vector<AudioFormatDescription>* _aidl_return) {
2336 std::vector<audio_format_t> formats;
2337
2338 if (mAudioPolicyManager == NULL) {
2339 return binderStatusFromStatusT(NO_INIT);
2340 }
2341 audio_utils::lock_guard _l(mMutex);
2342 AutoCallerClear acc;
2343 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
2344 aidl2legacy_AudioDeviceDescription_audio_devices_t(deviceAidl));
2345 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2346 mAudioPolicyManager->getHwOffloadFormatsSupportedForBluetoothMedia(device, &formats)));
2347 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2348 convertContainer<std::vector<AudioFormatDescription>>(
2349 formats,
2350 legacy2aidl_audio_format_t_AudioFormatDescription));
2351 return Status::ok();
2352 }
2353
setSurroundFormatEnabled(const AudioFormatDescription & audioFormatAidl,bool enabled)2354 Status AudioPolicyService::setSurroundFormatEnabled(
2355 const AudioFormatDescription& audioFormatAidl, bool enabled) {
2356 audio_format_t audioFormat = VALUE_OR_RETURN_BINDER_STATUS(
2357 aidl2legacy_AudioFormatDescription_audio_format_t(audioFormatAidl));
2358 if (mAudioPolicyManager == NULL) {
2359 return binderStatusFromStatusT(NO_INIT);
2360 }
2361 audio_utils::lock_guard _l(mMutex);
2362 AutoCallerClear acc;
2363 return binderStatusFromStatusT(
2364 mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));
2365 }
2366
convertInt32VectorToUidVectorWithLimit(const std::vector<int32_t> & uidsAidl,std::vector<uid_t> & uids)2367 Status convertInt32VectorToUidVectorWithLimit(
2368 const std::vector<int32_t>& uidsAidl, std::vector<uid_t>& uids) {
2369 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2370 convertRangeWithLimit(uidsAidl.begin(),
2371 uidsAidl.end(),
2372 std::back_inserter(uids),
2373 aidl2legacy_int32_t_uid_t,
2374 MAX_ITEMS_PER_LIST)));
2375
2376 return Status::ok();
2377 }
2378
setAssistantServicesUids(const std::vector<int32_t> & uidsAidl)2379 Status AudioPolicyService::setAssistantServicesUids(const std::vector<int32_t>& uidsAidl)
2380 {
2381 std::vector<uid_t> uids;
2382 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));
2383
2384 audio_utils::lock_guard _l(mMutex);
2385 mUidPolicy->setAssistantUids(uids);
2386 return Status::ok();
2387 }
2388
setActiveAssistantServicesUids(const std::vector<int32_t> & activeUidsAidl)2389 Status AudioPolicyService::setActiveAssistantServicesUids(
2390 const std::vector<int32_t>& activeUidsAidl) {
2391 std::vector<uid_t> activeUids;
2392 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(activeUidsAidl, activeUids));
2393
2394 audio_utils::lock_guard _l(mMutex);
2395 mUidPolicy->setActiveAssistantUids(activeUids);
2396 return Status::ok();
2397 }
2398
setA11yServicesUids(const std::vector<int32_t> & uidsAidl)2399 Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)
2400 {
2401 std::vector<uid_t> uids;
2402 RETURN_IF_BINDER_ERROR(convertInt32VectorToUidVectorWithLimit(uidsAidl, uids));
2403
2404 audio_utils::lock_guard _l(mMutex);
2405 mUidPolicy->setA11yUids(uids);
2406 return Status::ok();
2407 }
2408
setCurrentImeUid(int32_t uidAidl)2409 Status AudioPolicyService::setCurrentImeUid(int32_t uidAidl)
2410 {
2411 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2412 audio_utils::lock_guard _l(mMutex);
2413 mUidPolicy->setCurrentImeUid(uid);
2414 return Status::ok();
2415 }
2416
isHapticPlaybackSupported(bool * _aidl_return)2417 Status AudioPolicyService::isHapticPlaybackSupported(bool* _aidl_return)
2418 {
2419 if (mAudioPolicyManager == NULL) {
2420 return binderStatusFromStatusT(NO_INIT);
2421 }
2422 audio_utils::lock_guard _l(mMutex);
2423 AutoCallerClear acc;
2424 *_aidl_return = mAudioPolicyManager->isHapticPlaybackSupported();
2425 return Status::ok();
2426 }
2427
isUltrasoundSupported(bool * _aidl_return)2428 Status AudioPolicyService::isUltrasoundSupported(bool* _aidl_return)
2429 {
2430 if (mAudioPolicyManager == NULL) {
2431 return binderStatusFromStatusT(NO_INIT);
2432 }
2433 audio_utils::lock_guard _l(mMutex);
2434 AutoCallerClear acc;
2435 *_aidl_return = mAudioPolicyManager->isUltrasoundSupported();
2436 return Status::ok();
2437 }
2438
isHotwordStreamSupported(bool lookbackAudio,bool * _aidl_return)2439 Status AudioPolicyService::isHotwordStreamSupported(bool lookbackAudio, bool* _aidl_return)
2440 {
2441 if (mAudioPolicyManager == nullptr) {
2442 return binderStatusFromStatusT(NO_INIT);
2443 }
2444 audio_utils::lock_guard _l(mMutex);
2445 AutoCallerClear acc;
2446 *_aidl_return = mAudioPolicyManager->isHotwordStreamSupported(lookbackAudio);
2447 return Status::ok();
2448 }
2449
listAudioProductStrategies(std::vector<media::AudioProductStrategy> * _aidl_return)2450 Status AudioPolicyService::listAudioProductStrategies(
2451 std::vector<media::AudioProductStrategy>* _aidl_return) {
2452 AudioProductStrategyVector strategies;
2453
2454 if (mAudioPolicyManager == NULL) {
2455 return binderStatusFromStatusT(NO_INIT);
2456 }
2457 audio_utils::lock_guard _l(mMutex);
2458 RETURN_IF_BINDER_ERROR(
2459 binderStatusFromStatusT(mAudioPolicyManager->listAudioProductStrategies(strategies)));
2460 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2461 convertContainer<std::vector<media::AudioProductStrategy>>(
2462 strategies,
2463 legacy2aidl_AudioProductStrategy));
2464 return Status::ok();
2465 }
2466
getProductStrategyFromAudioAttributes(const media::audio::common::AudioAttributes & aaAidl,bool fallbackOnDefault,int32_t * _aidl_return)2467 Status AudioPolicyService::getProductStrategyFromAudioAttributes(
2468 const media::audio::common::AudioAttributes& aaAidl,
2469 bool fallbackOnDefault, int32_t* _aidl_return) {
2470 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
2471 aidl2legacy_AudioAttributes_audio_attributes_t(aaAidl));
2472 product_strategy_t productStrategy;
2473
2474 if (mAudioPolicyManager == NULL) {
2475 return binderStatusFromStatusT(NO_INIT);
2476 }
2477 audio_utils::lock_guard _l(mMutex);
2478 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2479 mAudioPolicyManager->getProductStrategyFromAudioAttributes(
2480 aa, productStrategy, fallbackOnDefault)));
2481 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2482 legacy2aidl_product_strategy_t_int32_t(productStrategy));
2483 return Status::ok();
2484 }
2485
listAudioVolumeGroups(std::vector<media::AudioVolumeGroup> * _aidl_return)2486 Status AudioPolicyService::listAudioVolumeGroups(std::vector<media::AudioVolumeGroup>* _aidl_return)
2487 {
2488 AudioVolumeGroupVector groups;
2489 if (mAudioPolicyManager == NULL) {
2490 return binderStatusFromStatusT(NO_INIT);
2491 }
2492 audio_utils::lock_guard _l(mMutex);
2493 RETURN_IF_BINDER_ERROR(
2494 binderStatusFromStatusT(mAudioPolicyManager->listAudioVolumeGroups(groups)));
2495 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2496 convertContainer<std::vector<media::AudioVolumeGroup>>(groups,
2497 legacy2aidl_AudioVolumeGroup));
2498 return Status::ok();
2499 }
2500
getVolumeGroupFromAudioAttributes(const media::audio::common::AudioAttributes & aaAidl,bool fallbackOnDefault,int32_t * _aidl_return)2501 Status AudioPolicyService::getVolumeGroupFromAudioAttributes(
2502 const media::audio::common::AudioAttributes& aaAidl,
2503 bool fallbackOnDefault, int32_t* _aidl_return) {
2504 audio_attributes_t aa = VALUE_OR_RETURN_BINDER_STATUS(
2505 aidl2legacy_AudioAttributes_audio_attributes_t(aaAidl));
2506 volume_group_t volumeGroup;
2507
2508 if (mAudioPolicyManager == NULL) {
2509 return binderStatusFromStatusT(NO_INIT);
2510 }
2511 audio_utils::lock_guard _l(mMutex);
2512 RETURN_IF_BINDER_ERROR(
2513 binderStatusFromStatusT(
2514 mAudioPolicyManager->getVolumeGroupFromAudioAttributes(
2515 aa, volumeGroup, fallbackOnDefault)));
2516 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_volume_group_t_int32_t(volumeGroup));
2517 return Status::ok();
2518 }
2519
setRttEnabled(bool enabled)2520 Status AudioPolicyService::setRttEnabled(bool enabled)
2521 {
2522 audio_utils::lock_guard _l(mMutex);
2523 mUidPolicy->setRttEnabled(enabled);
2524 return Status::ok();
2525 }
2526
isCallScreenModeSupported(bool * _aidl_return)2527 Status AudioPolicyService::isCallScreenModeSupported(bool* _aidl_return)
2528 {
2529 if (mAudioPolicyManager == NULL) {
2530 return binderStatusFromStatusT(NO_INIT);
2531 }
2532 audio_utils::lock_guard _l(mMutex);
2533 AutoCallerClear acc;
2534 *_aidl_return = mAudioPolicyManager->isCallScreenModeSupported();
2535 return Status::ok();
2536 }
2537
setDevicesRoleForStrategy(int32_t strategyAidl,media::DeviceRole roleAidl,const std::vector<AudioDevice> & devicesAidl)2538 Status AudioPolicyService::setDevicesRoleForStrategy(
2539 int32_t strategyAidl,
2540 media::DeviceRole roleAidl,
2541 const std::vector<AudioDevice>& devicesAidl) {
2542 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2543 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2544 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2545 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2546 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2547 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2548 aidl2legacy_AudioDeviceTypeAddress));
2549
2550 if (mAudioPolicyManager == NULL) {
2551 return binderStatusFromStatusT(NO_INIT);
2552 }
2553 audio_utils::lock_guard _l(mMutex);
2554 status_t status = mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices);
2555 if (status == NO_ERROR) {
2556 onCheckSpatializer_l();
2557 }
2558 return binderStatusFromStatusT(status);
2559 }
2560
removeDevicesRoleForStrategy(int32_t strategyAidl,media::DeviceRole roleAidl,const std::vector<AudioDevice> & devicesAidl)2561 Status AudioPolicyService::removeDevicesRoleForStrategy(
2562 int32_t strategyAidl,
2563 media::DeviceRole roleAidl,
2564 const std::vector<AudioDevice>& devicesAidl) {
2565 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2566 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2567 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2568 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2569 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2570 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2571 aidl2legacy_AudioDeviceTypeAddress));
2572
2573 if (mAudioPolicyManager == NULL) {
2574 return binderStatusFromStatusT(NO_INIT);
2575 }
2576 audio_utils::lock_guard _l(mMutex);
2577 status_t status = mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role, devices);
2578 if (status == NO_ERROR) {
2579 onCheckSpatializer_l();
2580 }
2581 return binderStatusFromStatusT(status);
2582 }
2583
clearDevicesRoleForStrategy(int32_t strategyAidl,media::DeviceRole roleAidl)2584 Status AudioPolicyService::clearDevicesRoleForStrategy(int32_t strategyAidl,
2585 media::DeviceRole roleAidl) {
2586 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2587 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2588 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2589 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2590 if (mAudioPolicyManager == NULL) {
2591 return binderStatusFromStatusT(NO_INIT);
2592 }
2593 audio_utils::lock_guard _l(mMutex);
2594 status_t status = mAudioPolicyManager->clearDevicesRoleForStrategy(strategy, role);
2595 if (status == NO_ERROR) {
2596 onCheckSpatializer_l();
2597 }
2598 return binderStatusFromStatusT(status);
2599 }
2600
getDevicesForRoleAndStrategy(int32_t strategyAidl,media::DeviceRole roleAidl,std::vector<AudioDevice> * _aidl_return)2601 Status AudioPolicyService::getDevicesForRoleAndStrategy(
2602 int32_t strategyAidl,
2603 media::DeviceRole roleAidl,
2604 std::vector<AudioDevice>* _aidl_return) {
2605 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2606 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2607 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2608 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2609 AudioDeviceTypeAddrVector devices;
2610
2611 if (mAudioPolicyManager == NULL) {
2612 return binderStatusFromStatusT(NO_INIT);
2613 }
2614 audio_utils::lock_guard _l(mMutex);
2615 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2616 mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices)));
2617 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2618 convertContainer<std::vector<AudioDevice>>(devices,
2619 legacy2aidl_AudioDeviceTypeAddress));
2620 return Status::ok();
2621 }
2622
registerSoundTriggerCaptureStateListener(const sp<media::ICaptureStateListener> & listener,bool * _aidl_return)2623 Status AudioPolicyService::registerSoundTriggerCaptureStateListener(
2624 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) {
2625 *_aidl_return = mCaptureStateNotifier.RegisterListener(listener);
2626 return Status::ok();
2627 }
2628
setDevicesRoleForCapturePreset(AudioSource audioSourceAidl,media::DeviceRole roleAidl,const std::vector<AudioDevice> & devicesAidl)2629 Status AudioPolicyService::setDevicesRoleForCapturePreset(
2630 AudioSource audioSourceAidl,
2631 media::DeviceRole roleAidl,
2632 const std::vector<AudioDevice>& devicesAidl) {
2633 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2634 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
2635 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2636 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2637 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2638 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2639 aidl2legacy_AudioDeviceTypeAddress));
2640
2641 if (mAudioPolicyManager == nullptr) {
2642 return binderStatusFromStatusT(NO_INIT);
2643 }
2644 audio_utils::lock_guard _l(mMutex);
2645 return binderStatusFromStatusT(
2646 mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices));
2647 }
2648
addDevicesRoleForCapturePreset(AudioSource audioSourceAidl,media::DeviceRole roleAidl,const std::vector<AudioDevice> & devicesAidl)2649 Status AudioPolicyService::addDevicesRoleForCapturePreset(
2650 AudioSource audioSourceAidl,
2651 media::DeviceRole roleAidl,
2652 const std::vector<AudioDevice>& devicesAidl) {
2653 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2654 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
2655 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2656 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2657 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2658 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2659 aidl2legacy_AudioDeviceTypeAddress));
2660
2661 if (mAudioPolicyManager == nullptr) {
2662 return binderStatusFromStatusT(NO_INIT);
2663 }
2664 audio_utils::lock_guard _l(mMutex);
2665 return binderStatusFromStatusT(
2666 mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices));
2667 }
2668
removeDevicesRoleForCapturePreset(AudioSource audioSourceAidl,media::DeviceRole roleAidl,const std::vector<AudioDevice> & devicesAidl)2669 Status AudioPolicyService::removeDevicesRoleForCapturePreset(
2670 AudioSource audioSourceAidl,
2671 media::DeviceRole roleAidl,
2672 const std::vector<AudioDevice>& devicesAidl) {
2673 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2674 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
2675 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2676 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2677 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2678 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2679 aidl2legacy_AudioDeviceTypeAddress));
2680
2681 if (mAudioPolicyManager == nullptr) {
2682 return binderStatusFromStatusT(NO_INIT);
2683 }
2684 audio_utils::lock_guard _l(mMutex);
2685 return binderStatusFromStatusT(
2686 mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
2687 }
2688
clearDevicesRoleForCapturePreset(AudioSource audioSourceAidl,media::DeviceRole roleAidl)2689 Status AudioPolicyService::clearDevicesRoleForCapturePreset(AudioSource audioSourceAidl,
2690 media::DeviceRole roleAidl) {
2691 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2692 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
2693 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2694 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2695
2696 if (mAudioPolicyManager == nullptr) {
2697 return binderStatusFromStatusT(NO_INIT);
2698 }
2699 audio_utils::lock_guard _l(mMutex);
2700 return binderStatusFromStatusT(
2701 mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role));
2702 }
2703
getDevicesForRoleAndCapturePreset(AudioSource audioSourceAidl,media::DeviceRole roleAidl,std::vector<AudioDevice> * _aidl_return)2704 Status AudioPolicyService::getDevicesForRoleAndCapturePreset(
2705 AudioSource audioSourceAidl,
2706 media::DeviceRole roleAidl,
2707 std::vector<AudioDevice>* _aidl_return) {
2708 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2709 aidl2legacy_AudioSource_audio_source_t(audioSourceAidl));
2710 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2711 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2712 AudioDeviceTypeAddrVector devices;
2713
2714 if (mAudioPolicyManager == nullptr) {
2715 return binderStatusFromStatusT(NO_INIT);
2716 }
2717 audio_utils::lock_guard _l(mMutex);
2718 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2719 mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices)));
2720 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2721 convertContainer<std::vector<AudioDevice>>(devices,
2722 legacy2aidl_AudioDeviceTypeAddress));
2723 return Status::ok();
2724 }
2725
getSpatializer(const sp<media::INativeSpatializerCallback> & callback,media::GetSpatializerResponse * _aidl_return)2726 Status AudioPolicyService::getSpatializer(
2727 const sp<media::INativeSpatializerCallback>& callback,
2728 media::GetSpatializerResponse* _aidl_return) {
2729 _aidl_return->spatializer = nullptr;
2730 if (callback == nullptr) {
2731 return binderStatusFromStatusT(BAD_VALUE);
2732 }
2733 if (mSpatializer != nullptr) {
2734 RETURN_IF_BINDER_ERROR(
2735 binderStatusFromStatusT(mSpatializer->registerCallback(callback)));
2736 _aidl_return->spatializer = mSpatializer;
2737 }
2738 return Status::ok();
2739 }
2740
canBeSpatialized(const std::optional<media::audio::common::AudioAttributes> & attrAidl,const std::optional<AudioConfig> & configAidl,const std::vector<AudioDevice> & devicesAidl,bool * _aidl_return)2741 Status AudioPolicyService::canBeSpatialized(
2742 const std::optional<media::audio::common::AudioAttributes>& attrAidl,
2743 const std::optional<AudioConfig>& configAidl,
2744 const std::vector<AudioDevice>& devicesAidl,
2745 bool* _aidl_return) {
2746 if (mAudioPolicyManager == nullptr) {
2747 return binderStatusFromStatusT(NO_INIT);
2748 }
2749 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
2750 if (attrAidl.has_value()) {
2751 attr = VALUE_OR_RETURN_BINDER_STATUS(
2752 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl.value()));
2753 }
2754 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
2755 if (configAidl.has_value()) {
2756 config = VALUE_OR_RETURN_BINDER_STATUS(
2757 aidl2legacy_AudioConfig_audio_config_t(configAidl.value(),
2758 false /*isInput*/));
2759 }
2760 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2761 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2762 aidl2legacy_AudioDeviceTypeAddress));
2763
2764 audio_utils::lock_guard _l(mMutex);
2765 *_aidl_return = mAudioPolicyManager->canBeSpatialized(&attr, &config, devices);
2766 return Status::ok();
2767 }
2768
getDirectPlaybackSupport(const media::audio::common::AudioAttributes & attrAidl,const AudioConfig & configAidl,media::AudioDirectMode * _aidl_return)2769 Status AudioPolicyService::getDirectPlaybackSupport(
2770 const media::audio::common::AudioAttributes &attrAidl,
2771 const AudioConfig &configAidl,
2772 media::AudioDirectMode *_aidl_return) {
2773 if (mAudioPolicyManager == nullptr) {
2774 return binderStatusFromStatusT(NO_INIT);
2775 }
2776 if (_aidl_return == nullptr) {
2777 return binderStatusFromStatusT(BAD_VALUE);
2778 }
2779 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
2780 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
2781 audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
2782 aidl2legacy_AudioConfig_audio_config_t(configAidl, false /*isInput*/));
2783 audio_utils::lock_guard _l(mMutex);
2784 *_aidl_return = static_cast<media::AudioDirectMode>(
2785 VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_direct_mode_t_int32_t_mask(
2786 mAudioPolicyManager->getDirectPlaybackSupport(&attr, &config))));
2787 return Status::ok();
2788 }
2789
getDirectProfilesForAttributes(const media::audio::common::AudioAttributes & attrAidl,std::vector<media::audio::common::AudioProfile> * _aidl_return)2790 Status AudioPolicyService::getDirectProfilesForAttributes(
2791 const media::audio::common::AudioAttributes& attrAidl,
2792 std::vector<media::audio::common::AudioProfile>* _aidl_return) {
2793 if (mAudioPolicyManager == nullptr) {
2794 return binderStatusFromStatusT(NO_INIT);
2795 }
2796 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
2797 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
2798 AudioProfileVector audioProfiles;
2799
2800 audio_utils::lock_guard _l(mMutex);
2801 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2802 mAudioPolicyManager->getDirectProfilesForAttributes(&attr, audioProfiles)));
2803 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2804 convertContainer<std::vector<media::audio::common::AudioProfile>>(
2805 audioProfiles, legacy2aidl_AudioProfile_common, false /*isInput*/));
2806
2807 return Status::ok();
2808 }
2809
getSupportedMixerAttributes(int32_t portIdAidl,std::vector<media::AudioMixerAttributesInternal> * _aidl_return)2810 Status AudioPolicyService::getSupportedMixerAttributes(
2811 int32_t portIdAidl, std::vector<media::AudioMixerAttributesInternal>* _aidl_return) {
2812 if (mAudioPolicyManager == nullptr) {
2813 return binderStatusFromStatusT(NO_INIT);
2814 }
2815
2816 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2817 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2818
2819 std::vector<audio_mixer_attributes_t> mixerAttrs;
2820 audio_utils::lock_guard _l(mMutex);
2821 RETURN_IF_BINDER_ERROR(
2822 binderStatusFromStatusT(mAudioPolicyManager->getSupportedMixerAttributes(
2823 portId, mixerAttrs)));
2824 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2825 convertContainer<std::vector<media::AudioMixerAttributesInternal>>(
2826 mixerAttrs,
2827 legacy2aidl_audio_mixer_attributes_t_AudioMixerAttributesInternal));
2828 return Status::ok();
2829 }
2830
setPreferredMixerAttributes(const media::audio::common::AudioAttributes & attrAidl,int32_t portIdAidl,int32_t uidAidl,const media::AudioMixerAttributesInternal & mixerAttrAidl)2831 Status AudioPolicyService::setPreferredMixerAttributes(
2832 const media::audio::common::AudioAttributes& attrAidl,
2833 int32_t portIdAidl,
2834 int32_t uidAidl,
2835 const media::AudioMixerAttributesInternal& mixerAttrAidl) {
2836 if (mAudioPolicyManager == nullptr) {
2837 return binderStatusFromStatusT(NO_INIT);
2838 }
2839
2840 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
2841 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
2842 audio_mixer_attributes_t mixerAttr = VALUE_OR_RETURN_BINDER_STATUS(
2843 aidl2legacy_AudioMixerAttributesInternal_audio_mixer_attributes_t(mixerAttrAidl));
2844 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2845 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2846 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2847
2848 audio_utils::lock_guard _l(mMutex);
2849 return binderStatusFromStatusT(
2850 mAudioPolicyManager->setPreferredMixerAttributes(&attr, portId, uid, &mixerAttr));
2851 }
2852
getPreferredMixerAttributes(const media::audio::common::AudioAttributes & attrAidl,int32_t portIdAidl,std::optional<media::AudioMixerAttributesInternal> * _aidl_return)2853 Status AudioPolicyService::getPreferredMixerAttributes(
2854 const media::audio::common::AudioAttributes& attrAidl,
2855 int32_t portIdAidl,
2856 std::optional<media::AudioMixerAttributesInternal>* _aidl_return) {
2857 if (mAudioPolicyManager == nullptr) {
2858 return binderStatusFromStatusT(NO_INIT);
2859 }
2860
2861 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
2862 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
2863 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2864 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2865
2866 audio_utils::lock_guard _l(mMutex);
2867 audio_mixer_attributes_t mixerAttr = AUDIO_MIXER_ATTRIBUTES_INITIALIZER;
2868 RETURN_IF_BINDER_ERROR(
2869 binderStatusFromStatusT(mAudioPolicyManager->getPreferredMixerAttributes(
2870 &attr, portId, &mixerAttr)));
2871 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2872 legacy2aidl_audio_mixer_attributes_t_AudioMixerAttributesInternal(mixerAttr));
2873 return Status::ok();
2874 }
2875
clearPreferredMixerAttributes(const media::audio::common::AudioAttributes & attrAidl,int32_t portIdAidl,int32_t uidAidl)2876 Status AudioPolicyService::clearPreferredMixerAttributes(
2877 const media::audio::common::AudioAttributes& attrAidl,
2878 int32_t portIdAidl,
2879 int32_t uidAidl) {
2880 if (mAudioPolicyManager == nullptr) {
2881 return binderStatusFromStatusT(NO_INIT);
2882 }
2883
2884 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
2885 aidl2legacy_AudioAttributes_audio_attributes_t(attrAidl));
2886 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
2887 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
2888 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
2889
2890 audio_utils::lock_guard _l(mMutex);
2891 return binderStatusFromStatusT(
2892 mAudioPolicyManager->clearPreferredMixerAttributes(&attr, portId, uid));
2893 }
2894
getPermissionController(sp<INativePermissionController> * out)2895 Status AudioPolicyService::getPermissionController(sp<INativePermissionController>* out) {
2896 *out = mPermissionController;
2897 return Status::ok();
2898 }
2899
getMmapPolicyInfos(AudioMMapPolicyType policyType,std::vector<AudioMMapPolicyInfo> * _aidl_return)2900 Status AudioPolicyService::getMmapPolicyInfos(
2901 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *_aidl_return) {
2902 if (mAudioPolicyManager == nullptr) {
2903 return binderStatusFromStatusT(NO_INIT);
2904 }
2905 audio_utils::lock_guard _l(mMutex);
2906 return binderStatusFromStatusT(
2907 mAudioPolicyManager->getMmapPolicyInfos(policyType, _aidl_return));
2908 }
2909
getMmapPolicyForDevice(AudioMMapPolicyType policyType,AudioMMapPolicyInfo * policyInfo)2910 Status AudioPolicyService::getMmapPolicyForDevice(
2911 AudioMMapPolicyType policyType, AudioMMapPolicyInfo *policyInfo) {
2912 if (mAudioPolicyManager == nullptr) {
2913 return binderStatusFromStatusT(NO_INIT);
2914 }
2915 audio_utils::lock_guard _l(mMutex);
2916 return binderStatusFromStatusT(
2917 mAudioPolicyManager->getMmapPolicyForDevice(policyType, policyInfo));
2918 }
2919
2920 } // namespace android
2921