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