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 "AudioPolicyIntefaceImpl"
18 //#define LOG_NDEBUG 0
19
20 #include "AudioPolicyService.h"
21 #include "TypeConverter.h"
22 #include <media/AidlConversion.h>
23 #include <media/AudioPolicy.h>
24 #include <media/AudioValidator.h>
25 #include <media/MediaMetricsItem.h>
26 #include <media/PolicyAidlConversion.h>
27 #include <utils/Log.h>
28 #include <android/content/AttributionSourceState.h>
29
30 #define VALUE_OR_RETURN_BINDER_STATUS(x) \
31 ({ auto _tmp = (x); \
32 if (!_tmp.ok()) return aidl_utils::binderStatusFromStatusT(_tmp.error()); \
33 std::move(_tmp.value()); })
34
35 #define RETURN_IF_BINDER_ERROR(x) \
36 { \
37 binder::Status _tmp = (x); \
38 if (!_tmp.isOk()) return _tmp; \
39 }
40
41 #define MAX_ITEMS_PER_LIST 1024
42
43 namespace android {
44 using binder::Status;
45 using aidl_utils::binderStatusFromStatusT;
46 using content::AttributionSourceState;
47
48 const std::vector<audio_usage_t>& SYSTEM_USAGES = {
49 AUDIO_USAGE_CALL_ASSISTANT,
50 AUDIO_USAGE_EMERGENCY,
51 AUDIO_USAGE_SAFETY,
52 AUDIO_USAGE_VEHICLE_STATUS,
53 AUDIO_USAGE_ANNOUNCEMENT
54 };
55
isSystemUsage(audio_usage_t usage)56 bool isSystemUsage(audio_usage_t usage) {
57 return std::find(std::begin(SYSTEM_USAGES), std::end(SYSTEM_USAGES), usage)
58 != std::end(SYSTEM_USAGES);
59 }
60
isSupportedSystemUsage(audio_usage_t usage)61 bool AudioPolicyService::isSupportedSystemUsage(audio_usage_t usage) {
62 return std::find(std::begin(mSupportedSystemUsages), std::end(mSupportedSystemUsages), usage)
63 != std::end(mSupportedSystemUsages);
64 }
65
validateUsage(audio_usage_t usage)66 status_t AudioPolicyService::validateUsage(audio_usage_t usage) {
67 return validateUsage(usage, getCallingAttributionSource());
68 }
69
validateUsage(audio_usage_t usage,const AttributionSourceState & attributionSource)70 status_t AudioPolicyService::validateUsage(audio_usage_t usage,
71 const AttributionSourceState& attributionSource) {
72 if (isSystemUsage(usage)) {
73 if (isSupportedSystemUsage(usage)) {
74 if (!modifyAudioRoutingAllowed(attributionSource)) {
75 ALOGE(("permission denied: modify audio routing not allowed "
76 "for attributionSource %s"), attributionSource.toString().c_str());
77 return PERMISSION_DENIED;
78 }
79 } else {
80 return BAD_VALUE;
81 }
82 }
83 return NO_ERROR;
84 }
85
86
87
88 // ----------------------------------------------------------------------------
89
doOnNewAudioModulesAvailable()90 void AudioPolicyService::doOnNewAudioModulesAvailable()
91 {
92 if (mAudioPolicyManager == NULL) return;
93 Mutex::Autolock _l(mLock);
94 AutoCallerClear acc;
95 mAudioPolicyManager->onNewAudioModulesAvailable();
96 }
97
setDeviceConnectionState(const media::AudioDevice & deviceAidl,media::AudioPolicyDeviceState stateAidl,const std::string & deviceNameAidl,media::audio::common::AudioFormat encodedFormatAidl)98 Status AudioPolicyService::setDeviceConnectionState(
99 const media::AudioDevice& deviceAidl,
100 media::AudioPolicyDeviceState stateAidl,
101 const std::string& deviceNameAidl,
102 media::audio::common::AudioFormat encodedFormatAidl) {
103 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
104 aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
105 audio_policy_dev_state_t state = VALUE_OR_RETURN_BINDER_STATUS(
106 aidl2legacy_AudioPolicyDeviceState_audio_policy_dev_state_t(stateAidl));
107 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
108 aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
109
110 if (mAudioPolicyManager == NULL) {
111 return binderStatusFromStatusT(NO_INIT);
112 }
113 if (!settingsAllowed()) {
114 return binderStatusFromStatusT(PERMISSION_DENIED);
115 }
116 if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE &&
117 state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) {
118 return binderStatusFromStatusT(BAD_VALUE);
119 }
120
121 ALOGV("setDeviceConnectionState()");
122 Mutex::Autolock _l(mLock);
123 AutoCallerClear acc;
124 status_t status = mAudioPolicyManager->setDeviceConnectionState(device, state,
125 deviceAidl.address.c_str(),
126 deviceNameAidl.c_str(),
127 encodedFormat);
128 if (status == NO_ERROR) {
129 onCheckSpatializer_l();
130 }
131 return binderStatusFromStatusT(status);
132 }
133
getDeviceConnectionState(const media::AudioDevice & deviceAidl,media::AudioPolicyDeviceState * _aidl_return)134 Status AudioPolicyService::getDeviceConnectionState(const media::AudioDevice& deviceAidl,
135 media::AudioPolicyDeviceState* _aidl_return) {
136 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
137 aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
138 if (mAudioPolicyManager == NULL) {
139 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
140 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
141 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE));
142 return Status::ok();
143 }
144 AutoCallerClear acc;
145 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
146 legacy2aidl_audio_policy_dev_state_t_AudioPolicyDeviceState(
147 mAudioPolicyManager->getDeviceConnectionState(device,
148 deviceAidl.address.c_str())));
149 return Status::ok();
150 }
151
handleDeviceConfigChange(const media::AudioDevice & deviceAidl,const std::string & deviceNameAidl,media::audio::common::AudioFormat encodedFormatAidl)152 Status AudioPolicyService::handleDeviceConfigChange(
153 const media::AudioDevice& deviceAidl,
154 const std::string& deviceNameAidl,
155 media::audio::common::AudioFormat encodedFormatAidl) {
156 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
157 aidl2legacy_int32_t_audio_devices_t(deviceAidl.type));
158 audio_format_t encodedFormat = VALUE_OR_RETURN_BINDER_STATUS(
159 aidl2legacy_AudioFormat_audio_format_t(encodedFormatAidl));
160
161 if (mAudioPolicyManager == NULL) {
162 return binderStatusFromStatusT(NO_INIT);
163 }
164 if (!settingsAllowed()) {
165 return binderStatusFromStatusT(PERMISSION_DENIED);
166 }
167
168 ALOGV("handleDeviceConfigChange()");
169 Mutex::Autolock _l(mLock);
170 AutoCallerClear acc;
171 status_t status = mAudioPolicyManager->handleDeviceConfigChange(
172 device, deviceAidl.address.c_str(), deviceNameAidl.c_str(), encodedFormat);
173
174 if (status == NO_ERROR) {
175 onCheckSpatializer_l();
176 }
177 return binderStatusFromStatusT(status);
178 }
179
setPhoneState(media::AudioMode stateAidl,int32_t uidAidl)180 Status AudioPolicyService::setPhoneState(media::AudioMode stateAidl, int32_t uidAidl)
181 {
182 audio_mode_t state = VALUE_OR_RETURN_BINDER_STATUS(
183 aidl2legacy_AudioMode_audio_mode_t(stateAidl));
184 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
185 if (mAudioPolicyManager == NULL) {
186 return binderStatusFromStatusT(NO_INIT);
187 }
188 if (!settingsAllowed()) {
189 return binderStatusFromStatusT(PERMISSION_DENIED);
190 }
191 if (uint32_t(state) >= AUDIO_MODE_CNT) {
192 return binderStatusFromStatusT(BAD_VALUE);
193 }
194
195 ALOGV("setPhoneState()");
196
197 // acquire lock before calling setMode() so that setMode() + setPhoneState() are an atomic
198 // operation from policy manager standpoint (no other operation (e.g track start or stop)
199 // can be interleaved).
200 Mutex::Autolock _l(mLock);
201 // TODO: check if it is more appropriate to do it in platform specific policy manager
202 AudioSystem::setMode(state);
203
204 AutoCallerClear acc;
205 mAudioPolicyManager->setPhoneState(state);
206 mPhoneState = state;
207 mPhoneStateOwnerUid = uid;
208 updateUidStates_l();
209 return Status::ok();
210 }
211
getPhoneState(media::AudioMode * _aidl_return)212 Status AudioPolicyService::getPhoneState(media::AudioMode* _aidl_return) {
213 Mutex::Autolock _l(mLock);
214 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_mode_t_AudioMode(mPhoneState));
215 return Status::ok();
216 }
217
setForceUse(media::AudioPolicyForceUse usageAidl,media::AudioPolicyForcedConfig configAidl)218 Status AudioPolicyService::setForceUse(media::AudioPolicyForceUse usageAidl,
219 media::AudioPolicyForcedConfig configAidl)
220 {
221 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
222 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
223 audio_policy_forced_cfg_t config = VALUE_OR_RETURN_BINDER_STATUS(
224 aidl2legacy_AudioPolicyForcedConfig_audio_policy_forced_cfg_t(configAidl));
225
226 if (mAudioPolicyManager == NULL) {
227 return binderStatusFromStatusT(NO_INIT);
228 }
229
230 if (!modifyAudioRoutingAllowed()) {
231 return binderStatusFromStatusT(PERMISSION_DENIED);
232 }
233
234 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
235 return binderStatusFromStatusT(BAD_VALUE);
236 }
237 if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) {
238 return binderStatusFromStatusT(BAD_VALUE);
239 }
240 ALOGV("setForceUse()");
241 Mutex::Autolock _l(mLock);
242 AutoCallerClear acc;
243 mAudioPolicyManager->setForceUse(usage, config);
244 onCheckSpatializer_l();
245 return Status::ok();
246 }
247
getForceUse(media::AudioPolicyForceUse usageAidl,media::AudioPolicyForcedConfig * _aidl_return)248 Status AudioPolicyService::getForceUse(media::AudioPolicyForceUse usageAidl,
249 media::AudioPolicyForcedConfig* _aidl_return) {
250 audio_policy_force_use_t usage = VALUE_OR_RETURN_BINDER_STATUS(
251 aidl2legacy_AudioPolicyForceUse_audio_policy_force_use_t(usageAidl));
252
253 if (mAudioPolicyManager == NULL) {
254 return binderStatusFromStatusT(NO_INIT);
255 }
256 if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) {
257 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
258 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(AUDIO_POLICY_FORCE_NONE));
259 return Status::ok();
260 }
261 AutoCallerClear acc;
262 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
263 legacy2aidl_audio_policy_forced_cfg_t_AudioPolicyForcedConfig(
264 mAudioPolicyManager->getForceUse(usage)));
265 return Status::ok();
266 }
267
getOutput(media::AudioStreamType streamAidl,int32_t * _aidl_return)268 Status AudioPolicyService::getOutput(media::AudioStreamType streamAidl, int32_t* _aidl_return)
269 {
270 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
271 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
272
273 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
274 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
275 legacy2aidl_audio_io_handle_t_int32_t(AUDIO_IO_HANDLE_NONE));
276 return Status::ok();
277 }
278 if (mAudioPolicyManager == NULL) {
279 return binderStatusFromStatusT(NO_INIT);
280 }
281 ALOGV("getOutput()");
282 Mutex::Autolock _l(mLock);
283 AutoCallerClear acc;
284 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
285 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutput(stream)));
286 return Status::ok();
287 }
288
getOutputForAttr(const media::AudioAttributesInternal & attrAidl,int32_t sessionAidl,const AttributionSourceState & attributionSource,const media::AudioConfig & configAidl,int32_t flagsAidl,int32_t selectedDeviceIdAidl,media::GetOutputForAttrResponse * _aidl_return)289 Status AudioPolicyService::getOutputForAttr(const media::AudioAttributesInternal& attrAidl,
290 int32_t sessionAidl,
291 const AttributionSourceState& attributionSource,
292 const media::AudioConfig& configAidl,
293 int32_t flagsAidl,
294 int32_t selectedDeviceIdAidl,
295 media::GetOutputForAttrResponse* _aidl_return)
296 {
297 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
298 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
299 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
300 aidl2legacy_int32_t_audio_session_t(sessionAidl));
301 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
302 audio_config_t config = VALUE_OR_RETURN_BINDER_STATUS(
303 aidl2legacy_AudioConfig_audio_config_t(configAidl));
304 audio_output_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
305 aidl2legacy_int32_t_audio_output_flags_t_mask(flagsAidl));
306 audio_port_handle_t selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
307 aidl2legacy_int32_t_audio_port_handle_t(selectedDeviceIdAidl));
308
309 audio_io_handle_t output;
310 audio_port_handle_t portId;
311 std::vector<audio_io_handle_t> secondaryOutputs;
312
313 if (mAudioPolicyManager == NULL) {
314 return binderStatusFromStatusT(NO_INIT);
315 }
316
317 RETURN_IF_BINDER_ERROR(
318 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
319 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage, attributionSource)));
320
321 ALOGV("%s()", __func__);
322 Mutex::Autolock _l(mLock);
323
324 // TODO b/182392553: refactor or remove
325 AttributionSourceState adjAttributionSource = attributionSource;
326 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
327 if (!isAudioServerOrMediaServerUid(callingUid) || attributionSource.uid == -1) {
328 int32_t callingUidAidl = VALUE_OR_RETURN_BINDER_STATUS(
329 legacy2aidl_uid_t_int32_t(callingUid));
330 ALOGW_IF(attributionSource.uid != -1 && attributionSource.uid != callingUidAidl,
331 "%s uid %d tried to pass itself off as %d", __func__,
332 callingUidAidl, attributionSource.uid);
333 adjAttributionSource.uid = callingUidAidl;
334 }
335 if (!mPackageManager.allowPlaybackCapture(VALUE_OR_RETURN_BINDER_STATUS(
336 aidl2legacy_int32_t_uid_t(adjAttributionSource.uid)))) {
337 attr.flags = static_cast<audio_flags_mask_t>(attr.flags | AUDIO_FLAG_NO_MEDIA_PROJECTION);
338 }
339 if (((attr.flags & (AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE)) != 0)
340 && !bypassInterruptionPolicyAllowed(adjAttributionSource)) {
341 attr.flags = static_cast<audio_flags_mask_t>(
342 attr.flags & ~(AUDIO_FLAG_BYPASS_INTERRUPTION_POLICY|AUDIO_FLAG_BYPASS_MUTE));
343 }
344 AutoCallerClear acc;
345 AudioPolicyInterface::output_type_t outputType;
346 status_t result = mAudioPolicyManager->getOutputForAttr(&attr, &output, session,
347 &stream,
348 adjAttributionSource,
349 &config,
350 &flags, &selectedDeviceId, &portId,
351 &secondaryOutputs,
352 &outputType);
353
354 // FIXME: Introduce a way to check for the the telephony device before opening the output
355 if (result == NO_ERROR) {
356 // enforce permission (if any) required for each type of input
357 switch (outputType) {
358 case AudioPolicyInterface::API_OUTPUT_LEGACY:
359 break;
360 case AudioPolicyInterface::API_OUTPUT_TELEPHONY_TX:
361 if (!modifyPhoneStateAllowed(adjAttributionSource)) {
362 ALOGE("%s() permission denied: modify phone state not allowed for uid %d",
363 __func__, adjAttributionSource.uid);
364 result = PERMISSION_DENIED;
365 }
366 break;
367 case AudioPolicyInterface::API_OUT_MIX_PLAYBACK:
368 if (!modifyAudioRoutingAllowed(adjAttributionSource)) {
369 ALOGE("%s() permission denied: modify audio routing not allowed for uid %d",
370 __func__, adjAttributionSource.uid);
371 result = PERMISSION_DENIED;
372 }
373 break;
374 case AudioPolicyInterface::API_OUTPUT_INVALID:
375 default:
376 LOG_ALWAYS_FATAL("%s() encountered an invalid output type %d",
377 __func__, (int)outputType);
378 }
379 }
380
381 if (result == NO_ERROR) {
382 sp<AudioPlaybackClient> client =
383 new AudioPlaybackClient(attr, output, adjAttributionSource, session,
384 portId, selectedDeviceId, stream);
385 mAudioPlaybackClients.add(portId, client);
386
387 _aidl_return->output = VALUE_OR_RETURN_BINDER_STATUS(
388 legacy2aidl_audio_io_handle_t_int32_t(output));
389 _aidl_return->stream = VALUE_OR_RETURN_BINDER_STATUS(
390 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
391 _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
392 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
393 _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
394 legacy2aidl_audio_port_handle_t_int32_t(portId));
395 _aidl_return->secondaryOutputs = VALUE_OR_RETURN_BINDER_STATUS(
396 convertContainer<std::vector<int32_t>>(secondaryOutputs,
397 legacy2aidl_audio_io_handle_t_int32_t));
398 }
399 return binderStatusFromStatusT(result);
400 }
401
getPlaybackClientAndEffects(audio_port_handle_t portId,sp<AudioPlaybackClient> & client,sp<AudioPolicyEffects> & effects,const char * context)402 void AudioPolicyService::getPlaybackClientAndEffects(audio_port_handle_t portId,
403 sp<AudioPlaybackClient>& client,
404 sp<AudioPolicyEffects>& effects,
405 const char *context)
406 {
407 Mutex::Autolock _l(mLock);
408 const ssize_t index = mAudioPlaybackClients.indexOfKey(portId);
409 if (index < 0) {
410 ALOGE("%s AudioTrack client not found for portId %d", context, portId);
411 return;
412 }
413 client = mAudioPlaybackClients.valueAt(index);
414 effects = mAudioPolicyEffects;
415 }
416
startOutput(int32_t portIdAidl)417 Status AudioPolicyService::startOutput(int32_t portIdAidl)
418 {
419 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
420 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
421 if (mAudioPolicyManager == NULL) {
422 return binderStatusFromStatusT(NO_INIT);
423 }
424 ALOGV("startOutput()");
425 sp<AudioPlaybackClient> client;
426 sp<AudioPolicyEffects>audioPolicyEffects;
427
428 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
429
430 if (audioPolicyEffects != 0) {
431 // create audio processors according to stream
432 status_t status = audioPolicyEffects->addOutputSessionEffects(
433 client->io, client->stream, client->session);
434 if (status != NO_ERROR && status != ALREADY_EXISTS) {
435 ALOGW("Failed to add effects on session %d", client->session);
436 }
437 }
438 Mutex::Autolock _l(mLock);
439 AutoCallerClear acc;
440 status_t status = mAudioPolicyManager->startOutput(portId);
441 if (status == NO_ERROR) {
442 client->active = true;
443 }
444 return binderStatusFromStatusT(status);
445 }
446
stopOutput(int32_t portIdAidl)447 Status AudioPolicyService::stopOutput(int32_t portIdAidl)
448 {
449 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
450 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
451 if (mAudioPolicyManager == NULL) {
452 return binderStatusFromStatusT(NO_INIT);
453 }
454 ALOGV("stopOutput()");
455 mOutputCommandThread->stopOutputCommand(portId);
456 return Status::ok();
457 }
458
doStopOutput(audio_port_handle_t portId)459 status_t AudioPolicyService::doStopOutput(audio_port_handle_t portId)
460 {
461 ALOGV("doStopOutput");
462 sp<AudioPlaybackClient> client;
463 sp<AudioPolicyEffects>audioPolicyEffects;
464
465 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
466
467 if (audioPolicyEffects != 0) {
468 // release audio processors from the stream
469 status_t status = audioPolicyEffects->releaseOutputSessionEffects(
470 client->io, client->stream, client->session);
471 if (status != NO_ERROR && status != ALREADY_EXISTS) {
472 ALOGW("Failed to release effects on session %d", client->session);
473 }
474 }
475 Mutex::Autolock _l(mLock);
476 AutoCallerClear acc;
477 status_t status = mAudioPolicyManager->stopOutput(portId);
478 if (status == NO_ERROR) {
479 client->active = false;
480 }
481 return status;
482 }
483
releaseOutput(int32_t portIdAidl)484 Status AudioPolicyService::releaseOutput(int32_t portIdAidl)
485 {
486 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
487 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
488 if (mAudioPolicyManager == NULL) {
489 return binderStatusFromStatusT(NO_INIT);
490 }
491 ALOGV("releaseOutput()");
492 mOutputCommandThread->releaseOutputCommand(portId);
493 return Status::ok();
494 }
495
doReleaseOutput(audio_port_handle_t portId)496 void AudioPolicyService::doReleaseOutput(audio_port_handle_t portId)
497 {
498 ALOGV("doReleaseOutput from tid %d", gettid());
499 sp<AudioPlaybackClient> client;
500 sp<AudioPolicyEffects> audioPolicyEffects;
501
502 getPlaybackClientAndEffects(portId, client, audioPolicyEffects, __func__);
503
504 if (audioPolicyEffects != 0 && client->active) {
505 // clean up effects if output was not stopped before being released
506 audioPolicyEffects->releaseOutputSessionEffects(
507 client->io, client->stream, client->session);
508 }
509 Mutex::Autolock _l(mLock);
510 mAudioPlaybackClients.removeItem(portId);
511
512 // called from internal thread: no need to clear caller identity
513 mAudioPolicyManager->releaseOutput(portId);
514 }
515
getInputForAttr(const media::AudioAttributesInternal & attrAidl,int32_t inputAidl,int32_t riidAidl,int32_t sessionAidl,const AttributionSourceState & attributionSource,const media::AudioConfigBase & configAidl,int32_t flagsAidl,int32_t selectedDeviceIdAidl,media::GetInputForAttrResponse * _aidl_return)516 Status AudioPolicyService::getInputForAttr(const media::AudioAttributesInternal& attrAidl,
517 int32_t inputAidl,
518 int32_t riidAidl,
519 int32_t sessionAidl,
520 const AttributionSourceState& attributionSource,
521 const media::AudioConfigBase& configAidl,
522 int32_t flagsAidl,
523 int32_t selectedDeviceIdAidl,
524 media::GetInputForAttrResponse* _aidl_return) {
525 audio_attributes_t attr = VALUE_OR_RETURN_BINDER_STATUS(
526 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
527 audio_io_handle_t input = VALUE_OR_RETURN_BINDER_STATUS(
528 aidl2legacy_int32_t_audio_io_handle_t(inputAidl));
529 audio_unique_id_t riid = VALUE_OR_RETURN_BINDER_STATUS(
530 aidl2legacy_int32_t_audio_unique_id_t(riidAidl));
531 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
532 aidl2legacy_int32_t_audio_session_t(sessionAidl));
533 audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
534 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
535 audio_input_flags_t flags = VALUE_OR_RETURN_BINDER_STATUS(
536 aidl2legacy_int32_t_audio_input_flags_t_mask(flagsAidl));
537 audio_port_handle_t selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
538 aidl2legacy_int32_t_audio_port_handle_t(selectedDeviceIdAidl));
539
540 audio_port_handle_t portId;
541
542 if (mAudioPolicyManager == NULL) {
543 return binderStatusFromStatusT(NO_INIT);
544 }
545
546 RETURN_IF_BINDER_ERROR(
547 binderStatusFromStatusT(AudioValidator::validateAudioAttributes(attr, "68953950")));
548
549 audio_source_t inputSource = attr.source;
550 if (inputSource == AUDIO_SOURCE_DEFAULT) {
551 inputSource = AUDIO_SOURCE_MIC;
552 }
553
554 // already checked by client, but double-check in case the client wrapper is bypassed
555 if ((inputSource < AUDIO_SOURCE_DEFAULT)
556 || (inputSource >= AUDIO_SOURCE_CNT
557 && inputSource != AUDIO_SOURCE_HOTWORD
558 && inputSource != AUDIO_SOURCE_FM_TUNER
559 && inputSource != AUDIO_SOURCE_ECHO_REFERENCE)) {
560 return binderStatusFromStatusT(BAD_VALUE);
561 }
562
563 // Make sure attribution source represents the current caller
564 AttributionSourceState adjAttributionSource = attributionSource;
565 // TODO b/182392553: refactor or remove
566 bool updatePid = (attributionSource.pid == -1);
567 const uid_t callingUid =IPCThreadState::self()->getCallingUid();
568 const uid_t currentUid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(
569 attributionSource.uid));
570 if (!isAudioServerOrMediaServerUid(callingUid)) {
571 ALOGW_IF(currentUid != (uid_t)-1 && currentUid != callingUid,
572 "%s uid %d tried to pass itself off as %d", __FUNCTION__, callingUid,
573 currentUid);
574 adjAttributionSource.uid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_uid_t_int32_t(
575 callingUid));
576 updatePid = true;
577 }
578
579 if (updatePid) {
580 const int32_t callingPid = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_pid_t_int32_t(
581 IPCThreadState::self()->getCallingPid()));
582 ALOGW_IF(attributionSource.pid != -1 && attributionSource.pid != callingPid,
583 "%s uid %d pid %d tried to pass itself off as pid %d",
584 __func__, adjAttributionSource.uid, callingPid, attributionSource.pid);
585 adjAttributionSource.pid = callingPid;
586 }
587
588 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attr.usage,
589 adjAttributionSource)));
590
591 // check calling permissions.
592 // Capturing from FM_TUNER source is controlled by captureTunerAudioInputAllowed() and
593 // captureAudioOutputAllowed() (deprecated) as this does not affect users privacy
594 // as does capturing from an actual microphone.
595 if (!(recordingAllowed(adjAttributionSource, attr.source)
596 || attr.source == AUDIO_SOURCE_FM_TUNER)) {
597 ALOGE("%s permission denied: recording not allowed for %s",
598 __func__, adjAttributionSource.toString().c_str());
599 return binderStatusFromStatusT(PERMISSION_DENIED);
600 }
601
602 bool canCaptureOutput = captureAudioOutputAllowed(adjAttributionSource);
603 if ((inputSource == AUDIO_SOURCE_VOICE_UPLINK ||
604 inputSource == AUDIO_SOURCE_VOICE_DOWNLINK ||
605 inputSource == AUDIO_SOURCE_VOICE_CALL ||
606 inputSource == AUDIO_SOURCE_ECHO_REFERENCE)
607 && !canCaptureOutput) {
608 return binderStatusFromStatusT(PERMISSION_DENIED);
609 }
610
611 if (inputSource == AUDIO_SOURCE_FM_TUNER
612 && !captureTunerAudioInputAllowed(adjAttributionSource)
613 && !canCaptureOutput) {
614 return binderStatusFromStatusT(PERMISSION_DENIED);
615 }
616
617 bool canCaptureHotword = captureHotwordAllowed(adjAttributionSource);
618 if ((inputSource == AUDIO_SOURCE_HOTWORD) && !canCaptureHotword) {
619 return binderStatusFromStatusT(PERMISSION_DENIED);
620 }
621
622 if (((flags & AUDIO_INPUT_FLAG_HW_HOTWORD) != 0)
623 && !canCaptureHotword) {
624 ALOGE("%s: permission denied: hotword mode not allowed"
625 " for uid %d pid %d", __func__, adjAttributionSource.uid, adjAttributionSource.pid);
626 return binderStatusFromStatusT(PERMISSION_DENIED);
627 }
628
629 sp<AudioPolicyEffects>audioPolicyEffects;
630 {
631 status_t status;
632 AudioPolicyInterface::input_type_t inputType;
633
634 Mutex::Autolock _l(mLock);
635 {
636 AutoCallerClear acc;
637 // the audio_in_acoustics_t parameter is ignored by get_input()
638 status = mAudioPolicyManager->getInputForAttr(&attr, &input, riid, session,
639 adjAttributionSource, &config,
640 flags, &selectedDeviceId,
641 &inputType, &portId);
642
643 }
644 audioPolicyEffects = mAudioPolicyEffects;
645
646 if (status == NO_ERROR) {
647 // enforce permission (if any) required for each type of input
648 switch (inputType) {
649 case AudioPolicyInterface::API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK:
650 // this use case has been validated in audio service with a MediaProjection token,
651 // and doesn't rely on regular permissions
652 case AudioPolicyInterface::API_INPUT_LEGACY:
653 break;
654 case AudioPolicyInterface::API_INPUT_TELEPHONY_RX:
655 // FIXME: use the same permission as for remote submix for now.
656 case AudioPolicyInterface::API_INPUT_MIX_CAPTURE:
657 if (!canCaptureOutput) {
658 ALOGE("getInputForAttr() permission denied: capture not allowed");
659 status = PERMISSION_DENIED;
660 }
661 break;
662 case AudioPolicyInterface::API_INPUT_MIX_EXT_POLICY_REROUTE:
663 if (!modifyAudioRoutingAllowed(adjAttributionSource)) {
664 ALOGE("getInputForAttr() permission denied: modify audio routing not allowed");
665 status = PERMISSION_DENIED;
666 }
667 break;
668 case AudioPolicyInterface::API_INPUT_INVALID:
669 default:
670 LOG_ALWAYS_FATAL("getInputForAttr() encountered an invalid input type %d",
671 (int)inputType);
672 }
673 }
674
675 if (status != NO_ERROR) {
676 if (status == PERMISSION_DENIED) {
677 AutoCallerClear acc;
678 mAudioPolicyManager->releaseInput(portId);
679 }
680 return binderStatusFromStatusT(status);
681 }
682
683 sp<AudioRecordClient> client = new AudioRecordClient(attr, input, session, portId,
684 selectedDeviceId, adjAttributionSource,
685 canCaptureOutput, canCaptureHotword,
686 mOutputCommandThread);
687 mAudioRecordClients.add(portId, client);
688 }
689
690 if (audioPolicyEffects != 0) {
691 // create audio pre processors according to input source
692 status_t status = audioPolicyEffects->addInputEffects(input, inputSource, session);
693 if (status != NO_ERROR && status != ALREADY_EXISTS) {
694 ALOGW("Failed to add effects on input %d", input);
695 }
696 }
697
698 _aidl_return->input = VALUE_OR_RETURN_BINDER_STATUS(
699 legacy2aidl_audio_io_handle_t_int32_t(input));
700 _aidl_return->selectedDeviceId = VALUE_OR_RETURN_BINDER_STATUS(
701 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
702 _aidl_return->portId = VALUE_OR_RETURN_BINDER_STATUS(
703 legacy2aidl_audio_port_handle_t_int32_t(portId));
704 return Status::ok();
705 }
706
getDeviceTypeStrForPortId(audio_port_handle_t portId)707 std::string AudioPolicyService::getDeviceTypeStrForPortId(audio_port_handle_t portId) {
708 struct audio_port_v7 port = {};
709 port.id = portId;
710 status_t status = mAudioPolicyManager->getAudioPort(&port);
711 if (status == NO_ERROR && port.type == AUDIO_PORT_TYPE_DEVICE) {
712 return toString(port.ext.device.type);
713 }
714 return {};
715 }
716
startInput(int32_t portIdAidl)717 Status AudioPolicyService::startInput(int32_t portIdAidl)
718 {
719 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
720 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
721
722 if (mAudioPolicyManager == NULL) {
723 return binderStatusFromStatusT(NO_INIT);
724 }
725 sp<AudioRecordClient> client;
726 {
727 Mutex::Autolock _l(mLock);
728
729 ssize_t index = mAudioRecordClients.indexOfKey(portId);
730 if (index < 0) {
731 return binderStatusFromStatusT(INVALID_OPERATION);
732 }
733 client = mAudioRecordClients.valueAt(index);
734 }
735
736 std::stringstream msg;
737 msg << "Audio recording on session " << client->session;
738
739 // check calling permissions
740 if (!(startRecording(client->attributionSource, String16(msg.str().c_str()),
741 client->attributes.source)
742 || client->attributes.source == AUDIO_SOURCE_FM_TUNER)) {
743 ALOGE("%s permission denied: recording not allowed for attribution source %s",
744 __func__, client->attributionSource.toString().c_str());
745 return binderStatusFromStatusT(PERMISSION_DENIED);
746 }
747
748 Mutex::Autolock _l(mLock);
749
750 client->active = true;
751 client->startTimeNs = systemTime();
752 updateUidStates_l();
753
754 status_t status;
755 {
756 AutoCallerClear acc;
757 status = mAudioPolicyManager->startInput(portId);
758
759 }
760
761 // including successes gets very verbose
762 // but once we cut over to statsd, log them all.
763 if (status != NO_ERROR) {
764
765 static constexpr char kAudioPolicy[] = "audiopolicy";
766
767 static constexpr char kAudioPolicyStatus[] = "android.media.audiopolicy.status";
768 static constexpr char kAudioPolicyRqstSrc[] = "android.media.audiopolicy.rqst.src";
769 static constexpr char kAudioPolicyRqstPkg[] = "android.media.audiopolicy.rqst.pkg";
770 static constexpr char kAudioPolicyRqstSession[] = "android.media.audiopolicy.rqst.session";
771 static constexpr char kAudioPolicyRqstDevice[] =
772 "android.media.audiopolicy.rqst.device";
773 static constexpr char kAudioPolicyActiveSrc[] = "android.media.audiopolicy.active.src";
774 static constexpr char kAudioPolicyActivePkg[] = "android.media.audiopolicy.active.pkg";
775 static constexpr char kAudioPolicyActiveSession[] =
776 "android.media.audiopolicy.active.session";
777 static constexpr char kAudioPolicyActiveDevice[] =
778 "android.media.audiopolicy.active.device";
779
780 mediametrics::Item *item = mediametrics::Item::create(kAudioPolicy);
781 if (item != NULL) {
782
783 item->setInt32(kAudioPolicyStatus, status);
784
785 item->setCString(kAudioPolicyRqstSrc,
786 toString(client->attributes.source).c_str());
787 item->setInt32(kAudioPolicyRqstSession, client->session);
788 if (client->attributionSource.packageName.has_value() &&
789 client->attributionSource.packageName.value().size() != 0) {
790 item->setCString(kAudioPolicyRqstPkg,
791 client->attributionSource.packageName.value().c_str());
792 } else {
793 item->setCString(kAudioPolicyRqstPkg,
794 std::to_string(client->attributionSource.uid).c_str());
795 }
796 item->setCString(
797 kAudioPolicyRqstDevice, getDeviceTypeStrForPortId(client->deviceId).c_str());
798
799 int count = mAudioRecordClients.size();
800 for (int i = 0; i < count ; i++) {
801 if (portId == mAudioRecordClients.keyAt(i)) {
802 continue;
803 }
804 sp<AudioRecordClient> other = mAudioRecordClients.valueAt(i);
805 if (other->active) {
806 // keeps the last of the clients marked active
807 item->setCString(kAudioPolicyActiveSrc,
808 toString(other->attributes.source).c_str());
809 item->setInt32(kAudioPolicyActiveSession, other->session);
810 if (other->attributionSource.packageName.has_value() &&
811 other->attributionSource.packageName.value().size() != 0) {
812 item->setCString(kAudioPolicyActivePkg,
813 other->attributionSource.packageName.value().c_str());
814 } else {
815 item->setCString(kAudioPolicyRqstPkg, std::to_string(
816 other->attributionSource.uid).c_str());
817 }
818 item->setCString(kAudioPolicyActiveDevice,
819 getDeviceTypeStrForPortId(other->deviceId).c_str());
820 }
821 }
822 item->selfrecord();
823 delete item;
824 item = NULL;
825 }
826 }
827
828 if (status != NO_ERROR) {
829 client->active = false;
830 client->startTimeNs = 0;
831 updateUidStates_l();
832 finishRecording(client->attributionSource, client->attributes.source);
833 }
834
835 return binderStatusFromStatusT(status);
836 }
837
stopInput(int32_t portIdAidl)838 Status AudioPolicyService::stopInput(int32_t portIdAidl)
839 {
840 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
841 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
842
843 if (mAudioPolicyManager == NULL) {
844 return binderStatusFromStatusT(NO_INIT);
845 }
846
847 Mutex::Autolock _l(mLock);
848
849 ssize_t index = mAudioRecordClients.indexOfKey(portId);
850 if (index < 0) {
851 return binderStatusFromStatusT(INVALID_OPERATION);
852 }
853 sp<AudioRecordClient> client = mAudioRecordClients.valueAt(index);
854
855 client->active = false;
856 client->startTimeNs = 0;
857
858 updateUidStates_l();
859
860 // finish the recording app op
861 finishRecording(client->attributionSource, client->attributes.source);
862 AutoCallerClear acc;
863 return binderStatusFromStatusT(mAudioPolicyManager->stopInput(portId));
864 }
865
releaseInput(int32_t portIdAidl)866 Status AudioPolicyService::releaseInput(int32_t portIdAidl)
867 {
868 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
869 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
870
871 if (mAudioPolicyManager == NULL) {
872 return binderStatusFromStatusT(NO_INIT);
873 }
874 sp<AudioPolicyEffects>audioPolicyEffects;
875 sp<AudioRecordClient> client;
876 {
877 Mutex::Autolock _l(mLock);
878 audioPolicyEffects = mAudioPolicyEffects;
879 ssize_t index = mAudioRecordClients.indexOfKey(portId);
880 if (index < 0) {
881 return Status::ok();
882 }
883 client = mAudioRecordClients.valueAt(index);
884
885 if (client->active) {
886 ALOGW("%s releasing active client portId %d", __FUNCTION__, portId);
887 client->active = false;
888 client->startTimeNs = 0;
889 updateUidStates_l();
890 }
891
892 mAudioRecordClients.removeItem(portId);
893 }
894 if (client == 0) {
895 return Status::ok();
896 }
897 if (audioPolicyEffects != 0) {
898 // release audio processors from the input
899 status_t status = audioPolicyEffects->releaseInputEffects(client->io, client->session);
900 if(status != NO_ERROR) {
901 ALOGW("Failed to release effects on input %d", client->io);
902 }
903 }
904 {
905 Mutex::Autolock _l(mLock);
906 AutoCallerClear acc;
907 mAudioPolicyManager->releaseInput(portId);
908 }
909 return Status::ok();
910 }
911
initStreamVolume(media::AudioStreamType streamAidl,int32_t indexMinAidl,int32_t indexMaxAidl)912 Status AudioPolicyService::initStreamVolume(media::AudioStreamType streamAidl,
913 int32_t indexMinAidl,
914 int32_t indexMaxAidl) {
915 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
916 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
917 int indexMin = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMinAidl));
918 int indexMax = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexMaxAidl));
919
920 if (mAudioPolicyManager == NULL) {
921 return binderStatusFromStatusT(NO_INIT);
922 }
923 if (!settingsAllowed()) {
924 return binderStatusFromStatusT(PERMISSION_DENIED);
925 }
926 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
927 return binderStatusFromStatusT(BAD_VALUE);
928 }
929 Mutex::Autolock _l(mLock);
930 AutoCallerClear acc;
931 mAudioPolicyManager->initStreamVolume(stream, indexMin, indexMax);
932 return binderStatusFromStatusT(NO_ERROR);
933 }
934
setStreamVolumeIndex(media::AudioStreamType streamAidl,int32_t deviceAidl,int32_t indexAidl)935 Status AudioPolicyService::setStreamVolumeIndex(media::AudioStreamType streamAidl,
936 int32_t deviceAidl, int32_t indexAidl) {
937 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
938 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
939 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
940 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
941 aidl2legacy_int32_t_audio_devices_t(deviceAidl));
942
943 if (mAudioPolicyManager == NULL) {
944 return binderStatusFromStatusT(NO_INIT);
945 }
946 if (!settingsAllowed()) {
947 return binderStatusFromStatusT(PERMISSION_DENIED);
948 }
949 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
950 return binderStatusFromStatusT(BAD_VALUE);
951 }
952 Mutex::Autolock _l(mLock);
953 AutoCallerClear acc;
954 return binderStatusFromStatusT(mAudioPolicyManager->setStreamVolumeIndex(stream,
955 index,
956 device));
957 }
958
getStreamVolumeIndex(media::AudioStreamType streamAidl,int32_t deviceAidl,int32_t * _aidl_return)959 Status AudioPolicyService::getStreamVolumeIndex(media::AudioStreamType streamAidl,
960 int32_t deviceAidl, int32_t* _aidl_return) {
961 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
962 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
963 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
964 aidl2legacy_int32_t_audio_devices_t(deviceAidl));
965 int index;
966
967 if (mAudioPolicyManager == NULL) {
968 return binderStatusFromStatusT(NO_INIT);
969 }
970 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
971 return binderStatusFromStatusT(BAD_VALUE);
972 }
973 Mutex::Autolock _l(mLock);
974 AutoCallerClear acc;
975 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
976 mAudioPolicyManager->getStreamVolumeIndex(stream, &index, device)));
977 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
978 return Status::ok();
979 }
980
setVolumeIndexForAttributes(const media::AudioAttributesInternal & attrAidl,int32_t deviceAidl,int32_t indexAidl)981 Status AudioPolicyService::setVolumeIndexForAttributes(
982 const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t indexAidl) {
983 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
984 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
985 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
986 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
987 aidl2legacy_int32_t_audio_devices_t(deviceAidl));
988 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
989 AudioValidator::validateAudioAttributes(attributes, "169572641")));
990
991 if (mAudioPolicyManager == NULL) {
992 return binderStatusFromStatusT(NO_INIT);
993 }
994 if (!settingsAllowed()) {
995 return binderStatusFromStatusT(PERMISSION_DENIED);
996 }
997 Mutex::Autolock _l(mLock);
998 AutoCallerClear acc;
999 return binderStatusFromStatusT(
1000 mAudioPolicyManager->setVolumeIndexForAttributes(attributes, index, device));
1001 }
1002
getVolumeIndexForAttributes(const media::AudioAttributesInternal & attrAidl,int32_t deviceAidl,int32_t * _aidl_return)1003 Status AudioPolicyService::getVolumeIndexForAttributes(
1004 const media::AudioAttributesInternal& attrAidl, int32_t deviceAidl, int32_t* _aidl_return) {
1005 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1006 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
1007 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1008 aidl2legacy_int32_t_audio_devices_t(deviceAidl));
1009 int index;
1010 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1011 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1012
1013 if (mAudioPolicyManager == NULL) {
1014 return binderStatusFromStatusT(NO_INIT);
1015 }
1016 Mutex::Autolock _l(mLock);
1017 AutoCallerClear acc;
1018 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1019 mAudioPolicyManager->getVolumeIndexForAttributes(attributes, index, device)));
1020 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1021 return Status::ok();
1022 }
1023
getMinVolumeIndexForAttributes(const media::AudioAttributesInternal & attrAidl,int32_t * _aidl_return)1024 Status AudioPolicyService::getMinVolumeIndexForAttributes(
1025 const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
1026 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1027 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
1028 int index;
1029 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1030 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1031
1032 if (mAudioPolicyManager == NULL) {
1033 return binderStatusFromStatusT(NO_INIT);
1034 }
1035 Mutex::Autolock _l(mLock);
1036 AutoCallerClear acc;
1037 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1038 mAudioPolicyManager->getMinVolumeIndexForAttributes(attributes, index)));
1039 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1040 return Status::ok();
1041 }
1042
getMaxVolumeIndexForAttributes(const media::AudioAttributesInternal & attrAidl,int32_t * _aidl_return)1043 Status AudioPolicyService::getMaxVolumeIndexForAttributes(
1044 const media::AudioAttributesInternal& attrAidl, int32_t* _aidl_return) {
1045 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1046 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl));
1047 int index;
1048 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1049 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1050
1051 if (mAudioPolicyManager == NULL) {
1052 return binderStatusFromStatusT(NO_INIT);
1053 }
1054 Mutex::Autolock _l(mLock);
1055 AutoCallerClear acc;
1056 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1057 mAudioPolicyManager->getMaxVolumeIndexForAttributes(attributes, index)));
1058 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(index));
1059 return Status::ok();
1060 }
1061
getStrategyForStream(media::AudioStreamType streamAidl,int32_t * _aidl_return)1062 Status AudioPolicyService::getStrategyForStream(media::AudioStreamType streamAidl,
1063 int32_t* _aidl_return) {
1064 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1065 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1066
1067 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1068 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1069 convertReinterpret<int32_t>(PRODUCT_STRATEGY_NONE));
1070 return Status::ok();
1071 }
1072 if (mAudioPolicyManager == NULL) {
1073 return binderStatusFromStatusT(NO_INIT);
1074 }
1075
1076 // DO NOT LOCK, may be called from AudioFlinger with lock held, reaching deadlock
1077 AutoCallerClear acc;
1078 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1079 legacy2aidl_product_strategy_t_int32_t(
1080 mAudioPolicyManager->getStrategyForStream(stream)));
1081 return Status::ok();
1082 }
1083
1084 //audio policy: use audio_device_t appropriately
1085
getDevicesForStream(media::AudioStreamType streamAidl,int32_t * _aidl_return)1086 Status AudioPolicyService::getDevicesForStream(media::AudioStreamType streamAidl,
1087 int32_t* _aidl_return) {
1088 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1089 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1090
1091 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1092 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1093 legacy2aidl_audio_devices_t_int32_t(AUDIO_DEVICE_NONE));
1094 return Status::ok();
1095 }
1096 if (mAudioPolicyManager == NULL) {
1097 return binderStatusFromStatusT(NO_INIT);
1098 }
1099 Mutex::Autolock _l(mLock);
1100 AutoCallerClear acc;
1101 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1102 legacy2aidl_audio_devices_t_int32_t(mAudioPolicyManager->getDevicesForStream(stream)));
1103 return Status::ok();
1104 }
1105
getDevicesForAttributes(const media::AudioAttributesEx & attrAidl,std::vector<media::AudioDevice> * _aidl_return)1106 Status AudioPolicyService::getDevicesForAttributes(const media::AudioAttributesEx& attrAidl,
1107 std::vector<media::AudioDevice>* _aidl_return)
1108 {
1109 AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
1110 aidl2legacy_AudioAttributesEx_AudioAttributes(attrAidl));
1111 AudioDeviceTypeAddrVector devices;
1112
1113 if (mAudioPolicyManager == NULL) {
1114 return binderStatusFromStatusT(NO_INIT);
1115 }
1116 Mutex::Autolock _l(mLock);
1117 AutoCallerClear acc;
1118 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1119 mAudioPolicyManager->getDevicesForAttributes(aa.getAttributes(), &devices)));
1120 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1121 convertContainer<std::vector<media::AudioDevice>>(devices,
1122 legacy2aidl_AudioDeviceTypeAddress));
1123 return Status::ok();
1124 }
1125
getOutputForEffect(const media::EffectDescriptor & descAidl,int32_t * _aidl_return)1126 Status AudioPolicyService::getOutputForEffect(const media::EffectDescriptor& descAidl,
1127 int32_t* _aidl_return) {
1128 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1129 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1130 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1131 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1132
1133 if (mAudioPolicyManager == NULL) {
1134 return binderStatusFromStatusT(NO_INIT);
1135 }
1136 Mutex::Autolock _l(mLock);
1137 AutoCallerClear acc;
1138 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1139 legacy2aidl_audio_io_handle_t_int32_t(mAudioPolicyManager->getOutputForEffect(&desc)));
1140 return Status::ok();
1141 }
1142
registerEffect(const media::EffectDescriptor & descAidl,int32_t ioAidl,int32_t strategyAidl,int32_t sessionAidl,int32_t idAidl)1143 Status AudioPolicyService::registerEffect(const media::EffectDescriptor& descAidl, int32_t ioAidl,
1144 int32_t strategyAidl, int32_t sessionAidl,
1145 int32_t idAidl) {
1146 effect_descriptor_t desc = VALUE_OR_RETURN_BINDER_STATUS(
1147 aidl2legacy_EffectDescriptor_effect_descriptor_t(descAidl));
1148 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1149 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1150 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
1151 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
1152 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
1153 aidl2legacy_int32_t_audio_session_t(sessionAidl));
1154 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1155 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1156 AudioValidator::validateEffectDescriptor(desc, "73126106")));
1157
1158 if (mAudioPolicyManager == NULL) {
1159 return binderStatusFromStatusT(NO_INIT);
1160 }
1161 Mutex::Autolock _l(mLock);
1162 AutoCallerClear acc;
1163 return binderStatusFromStatusT(
1164 mAudioPolicyManager->registerEffect(&desc, io, strategy, session, id));
1165 }
1166
unregisterEffect(int32_t idAidl)1167 Status AudioPolicyService::unregisterEffect(int32_t idAidl)
1168 {
1169 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1170 if (mAudioPolicyManager == NULL) {
1171 return binderStatusFromStatusT(NO_INIT);
1172 }
1173 Mutex::Autolock _l(mLock);
1174 AutoCallerClear acc;
1175 return binderStatusFromStatusT(mAudioPolicyManager->unregisterEffect(id));
1176 }
1177
setEffectEnabled(int32_t idAidl,bool enabled)1178 Status AudioPolicyService::setEffectEnabled(int32_t idAidl, bool enabled)
1179 {
1180 int id = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(idAidl));
1181 if (mAudioPolicyManager == NULL) {
1182 return binderStatusFromStatusT(NO_INIT);
1183 }
1184 Mutex::Autolock _l(mLock);
1185 AutoCallerClear acc;
1186 return binderStatusFromStatusT(mAudioPolicyManager->setEffectEnabled(id, enabled));
1187 }
1188
moveEffectsToIo(const std::vector<int32_t> & idsAidl,int32_t ioAidl)1189 Status AudioPolicyService::moveEffectsToIo(const std::vector<int32_t>& idsAidl, int32_t ioAidl)
1190
1191 {
1192 const std::vector<int>& ids = VALUE_OR_RETURN_BINDER_STATUS(
1193 convertContainer<std::vector<int>>(idsAidl, convertReinterpret<int, int32_t>));
1194 audio_io_handle_t io = VALUE_OR_RETURN_BINDER_STATUS(
1195 aidl2legacy_int32_t_audio_io_handle_t(ioAidl));
1196 if (ids.size() > MAX_ITEMS_PER_LIST) {
1197 return binderStatusFromStatusT(BAD_VALUE);
1198 }
1199
1200 if (mAudioPolicyManager == NULL) {
1201 return binderStatusFromStatusT(NO_INIT);
1202 }
1203 Mutex::Autolock _l(mLock);
1204 AutoCallerClear acc;
1205 return binderStatusFromStatusT(mAudioPolicyManager->moveEffectsToIo(ids, io));
1206 }
1207
isStreamActive(media::AudioStreamType streamAidl,int32_t inPastMsAidl,bool * _aidl_return)1208 Status AudioPolicyService::isStreamActive(media::AudioStreamType streamAidl, int32_t inPastMsAidl,
1209 bool* _aidl_return) {
1210 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1211 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1212 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1213
1214 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1215 *_aidl_return = false;
1216 return Status::ok();
1217 }
1218 if (mAudioPolicyManager == NULL) {
1219 return binderStatusFromStatusT(NO_INIT);
1220 }
1221 Mutex::Autolock _l(mLock);
1222 AutoCallerClear acc;
1223 *_aidl_return = mAudioPolicyManager->isStreamActive(stream, inPastMs);
1224 return Status::ok();
1225 }
1226
isStreamActiveRemotely(media::AudioStreamType streamAidl,int32_t inPastMsAidl,bool * _aidl_return)1227 Status AudioPolicyService::isStreamActiveRemotely(media::AudioStreamType streamAidl,
1228 int32_t inPastMsAidl,
1229 bool* _aidl_return) {
1230 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1231 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1232 uint32_t inPastMs = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(inPastMsAidl));
1233
1234 if (uint32_t(stream) >= AUDIO_STREAM_PUBLIC_CNT) {
1235 *_aidl_return = false;
1236 return Status::ok();
1237 }
1238 if (mAudioPolicyManager == NULL) {
1239 return binderStatusFromStatusT(NO_INIT);
1240 }
1241 Mutex::Autolock _l(mLock);
1242 AutoCallerClear acc;
1243 *_aidl_return = mAudioPolicyManager->isStreamActiveRemotely(stream, inPastMs);
1244 return Status::ok();
1245 }
1246
isSourceActive(media::AudioSourceType sourceAidl,bool * _aidl_return)1247 Status AudioPolicyService::isSourceActive(media::AudioSourceType sourceAidl, bool* _aidl_return) {
1248 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
1249 aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
1250 if (mAudioPolicyManager == NULL) {
1251 return binderStatusFromStatusT(NO_INIT);
1252 }
1253 Mutex::Autolock _l(mLock);
1254 AutoCallerClear acc;
1255 *_aidl_return = mAudioPolicyManager->isSourceActive(source);
1256 return Status::ok();
1257 }
1258
getAudioPolicyEffects(sp<AudioPolicyEffects> & audioPolicyEffects)1259 status_t AudioPolicyService::getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects)
1260 {
1261 if (mAudioPolicyManager == NULL) {
1262 return NO_INIT;
1263 }
1264 {
1265 Mutex::Autolock _l(mLock);
1266 audioPolicyEffects = mAudioPolicyEffects;
1267 }
1268 if (audioPolicyEffects == 0) {
1269 return NO_INIT;
1270 }
1271
1272 return OK;
1273 }
1274
queryDefaultPreProcessing(int32_t audioSessionAidl,media::Int * countAidl,std::vector<media::EffectDescriptor> * _aidl_return)1275 Status AudioPolicyService::queryDefaultPreProcessing(
1276 int32_t audioSessionAidl,
1277 media::Int* countAidl,
1278 std::vector<media::EffectDescriptor>* _aidl_return) {
1279 audio_session_t audioSession = VALUE_OR_RETURN_BINDER_STATUS(
1280 aidl2legacy_int32_t_audio_session_t(audioSessionAidl));
1281 uint32_t count = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(countAidl->value));
1282 if (count > AudioEffect::kMaxPreProcessing) {
1283 count = AudioEffect::kMaxPreProcessing;
1284 }
1285 uint32_t countReq = count;
1286 std::unique_ptr<effect_descriptor_t[]> descriptors(new effect_descriptor_t[count]);
1287
1288 sp<AudioPolicyEffects> audioPolicyEffects;
1289 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1290 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->queryDefaultInputEffects(
1291 (audio_session_t) audioSession, descriptors.get(), &count)));
1292 countReq = std::min(count, countReq);
1293 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1294 convertRange(descriptors.get(), descriptors.get() + countReq,
1295 std::back_inserter(*_aidl_return),
1296 legacy2aidl_effect_descriptor_t_EffectDescriptor)));
1297 countAidl->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(count));
1298 return Status::ok();
1299 }
1300
addSourceDefaultEffect(const media::AudioUuid & typeAidl,const std::string & opPackageNameAidl,const media::AudioUuid & uuidAidl,int32_t priority,media::AudioSourceType sourceAidl,int32_t * _aidl_return)1301 Status AudioPolicyService::addSourceDefaultEffect(const media::AudioUuid& typeAidl,
1302 const std::string& opPackageNameAidl,
1303 const media::AudioUuid& uuidAidl,
1304 int32_t priority,
1305 media::AudioSourceType sourceAidl,
1306 int32_t* _aidl_return) {
1307 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1308 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1309 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1310 aidl2legacy_string_view_String16(opPackageNameAidl));
1311 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1312 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1313 audio_source_t source = VALUE_OR_RETURN_BINDER_STATUS(
1314 aidl2legacy_AudioSourceType_audio_source_t(sourceAidl));
1315 audio_unique_id_t id;
1316
1317 sp<AudioPolicyEffects>audioPolicyEffects;
1318 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1319 if (!modifyDefaultAudioEffectsAllowed()) {
1320 return binderStatusFromStatusT(PERMISSION_DENIED);
1321 }
1322 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addSourceDefaultEffect(
1323 &type, opPackageName, &uuid, priority, source, &id)));
1324 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1325 return Status::ok();
1326 }
1327
addStreamDefaultEffect(const media::AudioUuid & typeAidl,const std::string & opPackageNameAidl,const media::AudioUuid & uuidAidl,int32_t priority,media::AudioUsage usageAidl,int32_t * _aidl_return)1328 Status AudioPolicyService::addStreamDefaultEffect(const media::AudioUuid& typeAidl,
1329 const std::string& opPackageNameAidl,
1330 const media::AudioUuid& uuidAidl,
1331 int32_t priority, media::AudioUsage usageAidl,
1332 int32_t* _aidl_return) {
1333 effect_uuid_t type = VALUE_OR_RETURN_BINDER_STATUS(
1334 aidl2legacy_AudioUuid_audio_uuid_t(typeAidl));
1335 String16 opPackageName = VALUE_OR_RETURN_BINDER_STATUS(
1336 aidl2legacy_string_view_String16(opPackageNameAidl));
1337 effect_uuid_t uuid = VALUE_OR_RETURN_BINDER_STATUS(
1338 aidl2legacy_AudioUuid_audio_uuid_t(uuidAidl));
1339 audio_usage_t usage = VALUE_OR_RETURN_BINDER_STATUS(
1340 aidl2legacy_AudioUsage_audio_usage_t(usageAidl));
1341 audio_unique_id_t id;
1342
1343 sp<AudioPolicyEffects> audioPolicyEffects;
1344 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1345 if (!modifyDefaultAudioEffectsAllowed()) {
1346 return binderStatusFromStatusT(PERMISSION_DENIED);
1347 }
1348 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(audioPolicyEffects->addStreamDefaultEffect(
1349 &type, opPackageName, &uuid, priority, usage, &id)));
1350 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_unique_id_t_int32_t(id));
1351 return Status::ok();
1352 }
1353
removeSourceDefaultEffect(int32_t idAidl)1354 Status AudioPolicyService::removeSourceDefaultEffect(int32_t idAidl)
1355 {
1356 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1357 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
1358 sp<AudioPolicyEffects>audioPolicyEffects;
1359 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1360 if (!modifyDefaultAudioEffectsAllowed()) {
1361 return binderStatusFromStatusT(PERMISSION_DENIED);
1362 }
1363 return binderStatusFromStatusT(audioPolicyEffects->removeSourceDefaultEffect(id));
1364 }
1365
removeStreamDefaultEffect(int32_t idAidl)1366 Status AudioPolicyService::removeStreamDefaultEffect(int32_t idAidl)
1367 {
1368 audio_unique_id_t id = VALUE_OR_RETURN_BINDER_STATUS(
1369 aidl2legacy_int32_t_audio_unique_id_t(idAidl));
1370 sp<AudioPolicyEffects>audioPolicyEffects;
1371 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(getAudioPolicyEffects(audioPolicyEffects)));
1372 if (!modifyDefaultAudioEffectsAllowed()) {
1373 return binderStatusFromStatusT(PERMISSION_DENIED);
1374 }
1375 return binderStatusFromStatusT(audioPolicyEffects->removeStreamDefaultEffect(id));
1376 }
1377
setSupportedSystemUsages(const std::vector<media::AudioUsage> & systemUsagesAidl)1378 Status AudioPolicyService::setSupportedSystemUsages(
1379 const std::vector<media::AudioUsage>& systemUsagesAidl) {
1380 size_t size = systemUsagesAidl.size();
1381 if (size > MAX_ITEMS_PER_LIST) {
1382 size = MAX_ITEMS_PER_LIST;
1383 }
1384 std::vector<audio_usage_t> systemUsages;
1385 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1386 convertRange(systemUsagesAidl.begin(), systemUsagesAidl.begin() + size,
1387 std::back_inserter(systemUsages), aidl2legacy_AudioUsage_audio_usage_t)));
1388
1389 Mutex::Autolock _l(mLock);
1390 if(!modifyAudioRoutingAllowed()) {
1391 return binderStatusFromStatusT(PERMISSION_DENIED);
1392 }
1393
1394 bool areAllSystemUsages = std::all_of(begin(systemUsages), end(systemUsages),
1395 [](audio_usage_t usage) { return isSystemUsage(usage); });
1396 if (!areAllSystemUsages) {
1397 return binderStatusFromStatusT(BAD_VALUE);
1398 }
1399
1400 mSupportedSystemUsages = systemUsages;
1401 return Status::ok();
1402 }
1403
setAllowedCapturePolicy(int32_t uidAidl,int32_t capturePolicyAidl)1404 Status AudioPolicyService::setAllowedCapturePolicy(int32_t uidAidl, int32_t capturePolicyAidl) {
1405 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1406 audio_flags_mask_t capturePolicy = VALUE_OR_RETURN_BINDER_STATUS(
1407 aidl2legacy_int32_t_audio_flags_mask_t_mask(capturePolicyAidl));
1408
1409 Mutex::Autolock _l(mLock);
1410 if (mAudioPolicyManager == NULL) {
1411 ALOGV("%s() mAudioPolicyManager == NULL", __func__);
1412 return binderStatusFromStatusT(NO_INIT);
1413 }
1414 return binderStatusFromStatusT(
1415 mAudioPolicyManager->setAllowedCapturePolicy(uid, capturePolicy));
1416 }
1417
getOffloadSupport(const media::AudioOffloadInfo & infoAidl,media::AudioOffloadMode * _aidl_return)1418 Status AudioPolicyService::getOffloadSupport(const media::AudioOffloadInfo& infoAidl,
1419 media::AudioOffloadMode* _aidl_return) {
1420 audio_offload_info_t info = VALUE_OR_RETURN_BINDER_STATUS(
1421 aidl2legacy_AudioOffloadInfo_audio_offload_info_t(infoAidl));
1422 if (mAudioPolicyManager == NULL) {
1423 ALOGV("mAudioPolicyManager == NULL");
1424 return binderStatusFromStatusT(AUDIO_OFFLOAD_NOT_SUPPORTED);
1425 }
1426 Mutex::Autolock _l(mLock);
1427 AutoCallerClear acc;
1428 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_offload_mode_t_AudioOffloadMode(
1429 mAudioPolicyManager->getOffloadSupport(info)));
1430 return Status::ok();
1431 }
1432
isDirectOutputSupported(const media::AudioConfigBase & configAidl,const media::AudioAttributesInternal & attributesAidl,bool * _aidl_return)1433 Status AudioPolicyService::isDirectOutputSupported(
1434 const media::AudioConfigBase& configAidl,
1435 const media::AudioAttributesInternal& attributesAidl,
1436 bool* _aidl_return) {
1437 audio_config_base_t config = VALUE_OR_RETURN_BINDER_STATUS(
1438 aidl2legacy_AudioConfigBase_audio_config_base_t(configAidl));
1439 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1440 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
1441 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1442 AudioValidator::validateAudioAttributes(attributes, "169572641")));
1443
1444 if (mAudioPolicyManager == NULL) {
1445 ALOGV("mAudioPolicyManager == NULL");
1446 return binderStatusFromStatusT(NO_INIT);
1447 }
1448
1449 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
1450
1451 Mutex::Autolock _l(mLock);
1452 *_aidl_return = mAudioPolicyManager->isDirectOutputSupported(config, attributes);
1453 return Status::ok();
1454 }
1455
1456
listAudioPorts(media::AudioPortRole roleAidl,media::AudioPortType typeAidl,media::Int * count,std::vector<media::AudioPort> * portsAidl,int32_t * _aidl_return)1457 Status AudioPolicyService::listAudioPorts(media::AudioPortRole roleAidl,
1458 media::AudioPortType typeAidl, media::Int* count,
1459 std::vector<media::AudioPort>* portsAidl,
1460 int32_t* _aidl_return) {
1461 audio_port_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
1462 aidl2legacy_AudioPortRole_audio_port_role_t(roleAidl));
1463 audio_port_type_t type = VALUE_OR_RETURN_BINDER_STATUS(
1464 aidl2legacy_AudioPortType_audio_port_type_t(typeAidl));
1465 unsigned int num_ports = VALUE_OR_RETURN_BINDER_STATUS(
1466 convertIntegral<unsigned int>(count->value));
1467 if (num_ports > MAX_ITEMS_PER_LIST) {
1468 num_ports = MAX_ITEMS_PER_LIST;
1469 }
1470 unsigned int numPortsReq = num_ports;
1471 std::unique_ptr<audio_port_v7[]> ports(new audio_port_v7[num_ports]);
1472 unsigned int generation;
1473
1474 Mutex::Autolock _l(mLock);
1475 if (mAudioPolicyManager == NULL) {
1476 return binderStatusFromStatusT(NO_INIT);
1477 }
1478 AutoCallerClear acc;
1479 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1480 mAudioPolicyManager->listAudioPorts(role, type, &num_ports, ports.get(), &generation)));
1481 numPortsReq = std::min(numPortsReq, num_ports);
1482 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1483 convertRange(ports.get(), ports.get() + numPortsReq, std::back_inserter(*portsAidl),
1484 legacy2aidl_audio_port_v7_AudioPort)));
1485 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_ports));
1486 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1487 return Status::ok();
1488 }
1489
getAudioPort(const media::AudioPort & portAidl,media::AudioPort * _aidl_return)1490 Status AudioPolicyService::getAudioPort(const media::AudioPort& portAidl,
1491 media::AudioPort* _aidl_return) {
1492 audio_port_v7 port = VALUE_OR_RETURN_BINDER_STATUS(
1493 aidl2legacy_AudioPort_audio_port_v7(portAidl));
1494 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPort(port)));
1495
1496 Mutex::Autolock _l(mLock);
1497 if (mAudioPolicyManager == NULL) {
1498 return binderStatusFromStatusT(NO_INIT);
1499 }
1500 AutoCallerClear acc;
1501 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(mAudioPolicyManager->getAudioPort(&port)));
1502 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_v7_AudioPort(port));
1503 return Status::ok();
1504 }
1505
createAudioPatch(const media::AudioPatch & patchAidl,int32_t handleAidl,int32_t * _aidl_return)1506 Status AudioPolicyService::createAudioPatch(const media::AudioPatch& patchAidl, int32_t handleAidl,
1507 int32_t* _aidl_return) {
1508 audio_patch patch = VALUE_OR_RETURN_BINDER_STATUS(
1509 aidl2legacy_AudioPatch_audio_patch(patchAidl));
1510 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1511 aidl2legacy_int32_t_audio_port_handle_t(handleAidl));
1512 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(AudioValidator::validateAudioPatch(patch)));
1513
1514 Mutex::Autolock _l(mLock);
1515 if(!modifyAudioRoutingAllowed()) {
1516 return binderStatusFromStatusT(PERMISSION_DENIED);
1517 }
1518 if (mAudioPolicyManager == NULL) {
1519 return binderStatusFromStatusT(NO_INIT);
1520 }
1521 AutoCallerClear acc;
1522 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1523 mAudioPolicyManager->createAudioPatch(&patch, &handle,
1524 IPCThreadState::self()->getCallingUid())));
1525 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
1526 return Status::ok();
1527 }
1528
releaseAudioPatch(int32_t handleAidl)1529 Status AudioPolicyService::releaseAudioPatch(int32_t handleAidl)
1530 {
1531 audio_patch_handle_t handle = VALUE_OR_RETURN_BINDER_STATUS(
1532 aidl2legacy_int32_t_audio_patch_handle_t(handleAidl));
1533 Mutex::Autolock _l(mLock);
1534 if(!modifyAudioRoutingAllowed()) {
1535 return binderStatusFromStatusT(PERMISSION_DENIED);
1536 }
1537 if (mAudioPolicyManager == NULL) {
1538 return binderStatusFromStatusT(NO_INIT);
1539 }
1540 AutoCallerClear acc;
1541 return binderStatusFromStatusT(
1542 mAudioPolicyManager->releaseAudioPatch(handle,
1543 IPCThreadState::self()->getCallingUid()));
1544 }
1545
listAudioPatches(media::Int * count,std::vector<media::AudioPatch> * patchesAidl,int32_t * _aidl_return)1546 Status AudioPolicyService::listAudioPatches(media::Int* count,
1547 std::vector<media::AudioPatch>* patchesAidl,
1548 int32_t* _aidl_return) {
1549 unsigned int num_patches = VALUE_OR_RETURN_BINDER_STATUS(
1550 convertIntegral<unsigned int>(count->value));
1551 if (num_patches > MAX_ITEMS_PER_LIST) {
1552 num_patches = MAX_ITEMS_PER_LIST;
1553 }
1554 unsigned int numPatchesReq = num_patches;
1555 std::unique_ptr<audio_patch[]> patches(new audio_patch[num_patches]);
1556 unsigned int generation;
1557
1558 Mutex::Autolock _l(mLock);
1559 if (mAudioPolicyManager == NULL) {
1560 return binderStatusFromStatusT(NO_INIT);
1561 }
1562 AutoCallerClear acc;
1563 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1564 mAudioPolicyManager->listAudioPatches(&num_patches, patches.get(), &generation)));
1565 numPatchesReq = std::min(numPatchesReq, num_patches);
1566 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1567 convertRange(patches.get(), patches.get() + numPatchesReq,
1568 std::back_inserter(*patchesAidl), legacy2aidl_audio_patch_AudioPatch)));
1569 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(num_patches));
1570 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int32_t>(generation));
1571 return Status::ok();
1572 }
1573
setAudioPortConfig(const media::AudioPortConfig & configAidl)1574 Status AudioPolicyService::setAudioPortConfig(const media::AudioPortConfig& configAidl)
1575 {
1576 audio_port_config config = VALUE_OR_RETURN_BINDER_STATUS(
1577 aidl2legacy_AudioPortConfig_audio_port_config(configAidl));
1578 RETURN_IF_BINDER_ERROR(
1579 binderStatusFromStatusT(AudioValidator::validateAudioPortConfig(config)));
1580
1581 Mutex::Autolock _l(mLock);
1582 if(!modifyAudioRoutingAllowed()) {
1583 return binderStatusFromStatusT(PERMISSION_DENIED);
1584 }
1585 if (mAudioPolicyManager == NULL) {
1586 return binderStatusFromStatusT(NO_INIT);
1587 }
1588 AutoCallerClear acc;
1589 return binderStatusFromStatusT(mAudioPolicyManager->setAudioPortConfig(&config));
1590 }
1591
acquireSoundTriggerSession(media::SoundTriggerSession * _aidl_return)1592 Status AudioPolicyService::acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return)
1593 {
1594 audio_session_t session;
1595 audio_io_handle_t ioHandle;
1596 audio_devices_t device;
1597
1598 {
1599 Mutex::Autolock _l(mLock);
1600 if (mAudioPolicyManager == NULL) {
1601 return binderStatusFromStatusT(NO_INIT);
1602 }
1603 AutoCallerClear acc;
1604 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1605 mAudioPolicyManager->acquireSoundTriggerSession(&session, &ioHandle, &device)));
1606 }
1607
1608 _aidl_return->session = VALUE_OR_RETURN_BINDER_STATUS(
1609 legacy2aidl_audio_session_t_int32_t(session));
1610 _aidl_return->ioHandle = VALUE_OR_RETURN_BINDER_STATUS(
1611 legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
1612 _aidl_return->device = VALUE_OR_RETURN_BINDER_STATUS(
1613 legacy2aidl_audio_devices_t_int32_t(device));
1614 return Status::ok();
1615 }
1616
releaseSoundTriggerSession(int32_t sessionAidl)1617 Status AudioPolicyService::releaseSoundTriggerSession(int32_t sessionAidl)
1618 {
1619 audio_session_t session = VALUE_OR_RETURN_BINDER_STATUS(
1620 aidl2legacy_int32_t_audio_session_t(sessionAidl));
1621 Mutex::Autolock _l(mLock);
1622 if (mAudioPolicyManager == NULL) {
1623 return binderStatusFromStatusT(NO_INIT);
1624 }
1625 AutoCallerClear acc;
1626 return binderStatusFromStatusT(mAudioPolicyManager->releaseSoundTriggerSession(session));
1627 }
1628
registerPolicyMixes(const std::vector<media::AudioMix> & mixesAidl,bool registration)1629 Status AudioPolicyService::registerPolicyMixes(const std::vector<media::AudioMix>& mixesAidl,
1630 bool registration) {
1631 size_t size = mixesAidl.size();
1632 if (size > MAX_MIXES_PER_POLICY) {
1633 size = MAX_MIXES_PER_POLICY;
1634 }
1635 Vector<AudioMix> mixes;
1636 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1637 convertRange(mixesAidl.begin(), mixesAidl.begin() + size, std::back_inserter(mixes),
1638 aidl2legacy_AudioMix)));
1639
1640 Mutex::Autolock _l(mLock);
1641
1642 // loopback|render only need a MediaProjection (checked in caller AudioService.java)
1643 bool needModifyAudioRouting = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1644 return !is_mix_loopback_render(mix.mRouteFlags); });
1645 if (needModifyAudioRouting && !modifyAudioRoutingAllowed()) {
1646 return binderStatusFromStatusT(PERMISSION_DENIED);
1647 }
1648
1649 // If one of the mixes has needCaptureVoiceCommunicationOutput set to true, then we
1650 // need to verify that the caller still has CAPTURE_VOICE_COMMUNICATION_OUTPUT
1651 bool needCaptureVoiceCommunicationOutput =
1652 std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1653 return mix.mVoiceCommunicationCaptureAllowed; });
1654
1655 bool needCaptureMediaOutput = std::any_of(mixes.begin(), mixes.end(), [](auto& mix) {
1656 return mix.mAllowPrivilegedMediaPlaybackCapture; });
1657
1658 const AttributionSourceState attributionSource = getCallingAttributionSource();
1659
1660
1661 if (needCaptureMediaOutput && !captureMediaOutputAllowed(attributionSource)) {
1662 return binderStatusFromStatusT(PERMISSION_DENIED);
1663 }
1664
1665 if (needCaptureVoiceCommunicationOutput &&
1666 !captureVoiceCommunicationOutputAllowed(attributionSource)) {
1667 return binderStatusFromStatusT(PERMISSION_DENIED);
1668 }
1669
1670 if (mAudioPolicyManager == NULL) {
1671 return binderStatusFromStatusT(NO_INIT);
1672 }
1673 AutoCallerClear acc;
1674 if (registration) {
1675 return binderStatusFromStatusT(mAudioPolicyManager->registerPolicyMixes(mixes));
1676 } else {
1677 return binderStatusFromStatusT(mAudioPolicyManager->unregisterPolicyMixes(mixes));
1678 }
1679 }
1680
setUidDeviceAffinities(int32_t uidAidl,const std::vector<media::AudioDevice> & devicesAidl)1681 Status AudioPolicyService::setUidDeviceAffinities(
1682 int32_t uidAidl,
1683 const std::vector<media::AudioDevice>& devicesAidl) {
1684 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1685 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
1686 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
1687 aidl2legacy_AudioDeviceTypeAddress));
1688
1689 Mutex::Autolock _l(mLock);
1690 if(!modifyAudioRoutingAllowed()) {
1691 return binderStatusFromStatusT(PERMISSION_DENIED);
1692 }
1693 if (mAudioPolicyManager == NULL) {
1694 return binderStatusFromStatusT(NO_INIT);
1695 }
1696 AutoCallerClear acc;
1697 return binderStatusFromStatusT(mAudioPolicyManager->setUidDeviceAffinities(uid, devices));
1698 }
1699
removeUidDeviceAffinities(int32_t uidAidl)1700 Status AudioPolicyService::removeUidDeviceAffinities(int32_t uidAidl) {
1701 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1702
1703 Mutex::Autolock _l(mLock);
1704 if(!modifyAudioRoutingAllowed()) {
1705 return binderStatusFromStatusT(PERMISSION_DENIED);
1706 }
1707 if (mAudioPolicyManager == NULL) {
1708 return binderStatusFromStatusT(NO_INIT);
1709 }
1710 AutoCallerClear acc;
1711 return binderStatusFromStatusT(mAudioPolicyManager->removeUidDeviceAffinities(uid));
1712 }
1713
setUserIdDeviceAffinities(int32_t userIdAidl,const std::vector<media::AudioDevice> & devicesAidl)1714 Status AudioPolicyService::setUserIdDeviceAffinities(
1715 int32_t userIdAidl,
1716 const std::vector<media::AudioDevice>& devicesAidl) {
1717 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
1718 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
1719 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
1720 aidl2legacy_AudioDeviceTypeAddress));
1721
1722 Mutex::Autolock _l(mLock);
1723 if(!modifyAudioRoutingAllowed()) {
1724 return binderStatusFromStatusT(PERMISSION_DENIED);
1725 }
1726 if (mAudioPolicyManager == NULL) {
1727 return binderStatusFromStatusT(NO_INIT);
1728 }
1729 AutoCallerClear acc;
1730 return binderStatusFromStatusT(mAudioPolicyManager->setUserIdDeviceAffinities(userId, devices));
1731 }
1732
removeUserIdDeviceAffinities(int32_t userIdAidl)1733 Status AudioPolicyService::removeUserIdDeviceAffinities(int32_t userIdAidl) {
1734 int userId = VALUE_OR_RETURN_BINDER_STATUS(convertReinterpret<int>(userIdAidl));
1735
1736 Mutex::Autolock _l(mLock);
1737 if(!modifyAudioRoutingAllowed()) {
1738 return binderStatusFromStatusT(PERMISSION_DENIED);
1739 }
1740 if (mAudioPolicyManager == NULL) {
1741 return binderStatusFromStatusT(NO_INIT);
1742 }
1743 AutoCallerClear acc;
1744 return binderStatusFromStatusT(mAudioPolicyManager->removeUserIdDeviceAffinities(userId));
1745 }
1746
startAudioSource(const media::AudioPortConfig & sourceAidl,const media::AudioAttributesInternal & attributesAidl,int32_t * _aidl_return)1747 Status AudioPolicyService::startAudioSource(const media::AudioPortConfig& sourceAidl,
1748 const media::AudioAttributesInternal& attributesAidl,
1749 int32_t* _aidl_return) {
1750 audio_port_config source = VALUE_OR_RETURN_BINDER_STATUS(
1751 aidl2legacy_AudioPortConfig_audio_port_config(sourceAidl));
1752 audio_attributes_t attributes = VALUE_OR_RETURN_BINDER_STATUS(
1753 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attributesAidl));
1754 audio_port_handle_t portId;
1755 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1756 AudioValidator::validateAudioPortConfig(source)));
1757 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1758 AudioValidator::validateAudioAttributes(attributes, "68953950")));
1759
1760 Mutex::Autolock _l(mLock);
1761 if (mAudioPolicyManager == NULL) {
1762 return binderStatusFromStatusT(NO_INIT);
1763 }
1764
1765 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(validateUsage(attributes.usage)));
1766
1767 // startAudioSource should be created as the calling uid
1768 const uid_t callingUid = IPCThreadState::self()->getCallingUid();
1769 AutoCallerClear acc;
1770 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1771 mAudioPolicyManager->startAudioSource(&source, &attributes, &portId, callingUid)));
1772 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_audio_port_handle_t_int32_t(portId));
1773 return Status::ok();
1774 }
1775
stopAudioSource(int32_t portIdAidl)1776 Status AudioPolicyService::stopAudioSource(int32_t portIdAidl)
1777 {
1778 audio_port_handle_t portId = VALUE_OR_RETURN_BINDER_STATUS(
1779 aidl2legacy_int32_t_audio_port_handle_t(portIdAidl));
1780
1781 Mutex::Autolock _l(mLock);
1782 if (mAudioPolicyManager == NULL) {
1783 return binderStatusFromStatusT(NO_INIT);
1784 }
1785 AutoCallerClear acc;
1786 return binderStatusFromStatusT(mAudioPolicyManager->stopAudioSource(portId));
1787 }
1788
setMasterMono(bool mono)1789 Status AudioPolicyService::setMasterMono(bool mono)
1790 {
1791 if (mAudioPolicyManager == NULL) {
1792 return binderStatusFromStatusT(NO_INIT);
1793 }
1794 if (!settingsAllowed()) {
1795 return binderStatusFromStatusT(PERMISSION_DENIED);
1796 }
1797 Mutex::Autolock _l(mLock);
1798 AutoCallerClear acc;
1799 return binderStatusFromStatusT(mAudioPolicyManager->setMasterMono(mono));
1800 }
1801
getMasterMono(bool * _aidl_return)1802 Status AudioPolicyService::getMasterMono(bool* _aidl_return)
1803 {
1804 if (mAudioPolicyManager == NULL) {
1805 return binderStatusFromStatusT(NO_INIT);
1806 }
1807 Mutex::Autolock _l(mLock);
1808 AutoCallerClear acc;
1809 return binderStatusFromStatusT(mAudioPolicyManager->getMasterMono(_aidl_return));
1810 }
1811
1812
getStreamVolumeDB(media::AudioStreamType streamAidl,int32_t indexAidl,int32_t deviceAidl,float * _aidl_return)1813 Status AudioPolicyService::getStreamVolumeDB(media::AudioStreamType streamAidl, int32_t indexAidl,
1814 int32_t deviceAidl, float* _aidl_return) {
1815 audio_stream_type_t stream = VALUE_OR_RETURN_BINDER_STATUS(
1816 aidl2legacy_AudioStreamType_audio_stream_type_t(streamAidl));
1817 int index = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<int>(indexAidl));
1818 audio_devices_t device = VALUE_OR_RETURN_BINDER_STATUS(
1819 aidl2legacy_int32_t_audio_devices_t(deviceAidl));
1820
1821 if (mAudioPolicyManager == NULL) {
1822 return binderStatusFromStatusT(NO_INIT);
1823 }
1824 Mutex::Autolock _l(mLock);
1825 AutoCallerClear acc;
1826 *_aidl_return = mAudioPolicyManager->getStreamVolumeDB(stream, index, device);
1827 return Status::ok();
1828 }
1829
getSurroundFormats(media::Int * count,std::vector<media::audio::common::AudioFormat> * formats,std::vector<bool> * formatsEnabled)1830 Status AudioPolicyService::getSurroundFormats(media::Int* count,
1831 std::vector<media::audio::common::AudioFormat>* formats,
1832 std::vector<bool>* formatsEnabled) {
1833 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
1834 convertIntegral<unsigned int>(count->value));
1835 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
1836 numSurroundFormats = MAX_ITEMS_PER_LIST;
1837 }
1838 unsigned int numSurroundFormatsReq = numSurroundFormats;
1839 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
1840 std::unique_ptr<bool[]>surroundFormatsEnabled(new bool[numSurroundFormats]);
1841
1842 if (mAudioPolicyManager == NULL) {
1843 return binderStatusFromStatusT(NO_INIT);
1844 }
1845 Mutex::Autolock _l(mLock);
1846 AutoCallerClear acc;
1847 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1848 mAudioPolicyManager->getSurroundFormats(&numSurroundFormats, surroundFormats.get(),
1849 surroundFormatsEnabled.get())));
1850 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
1851 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1852 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
1853 std::back_inserter(*formats), legacy2aidl_audio_format_t_AudioFormat)));
1854 formatsEnabled->insert(
1855 formatsEnabled->begin(),
1856 surroundFormatsEnabled.get(),
1857 surroundFormatsEnabled.get() + numSurroundFormatsReq);
1858 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
1859 return Status::ok();
1860 }
1861
getReportedSurroundFormats(media::Int * count,std::vector<media::audio::common::AudioFormat> * formats)1862 Status AudioPolicyService::getReportedSurroundFormats(
1863 media::Int* count, std::vector<media::audio::common::AudioFormat>* formats) {
1864 unsigned int numSurroundFormats = VALUE_OR_RETURN_BINDER_STATUS(
1865 convertIntegral<unsigned int>(count->value));
1866 if (numSurroundFormats > MAX_ITEMS_PER_LIST) {
1867 numSurroundFormats = MAX_ITEMS_PER_LIST;
1868 }
1869 unsigned int numSurroundFormatsReq = numSurroundFormats;
1870 std::unique_ptr<audio_format_t[]>surroundFormats(new audio_format_t[numSurroundFormats]);
1871
1872 if (mAudioPolicyManager == NULL) {
1873 return binderStatusFromStatusT(NO_INIT);
1874 }
1875 Mutex::Autolock _l(mLock);
1876 AutoCallerClear acc;
1877 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1878 mAudioPolicyManager->getReportedSurroundFormats(
1879 &numSurroundFormats, surroundFormats.get())));
1880 numSurroundFormatsReq = std::min(numSurroundFormats, numSurroundFormatsReq);
1881 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1882 convertRange(surroundFormats.get(), surroundFormats.get() + numSurroundFormatsReq,
1883 std::back_inserter(*formats), legacy2aidl_audio_format_t_AudioFormat)));
1884 count->value = VALUE_OR_RETURN_BINDER_STATUS(convertIntegral<uint32_t>(numSurroundFormats));
1885 return Status::ok();
1886 }
1887
getHwOffloadEncodingFormatsSupportedForA2DP(std::vector<media::audio::common::AudioFormat> * _aidl_return)1888 Status AudioPolicyService::getHwOffloadEncodingFormatsSupportedForA2DP(
1889 std::vector<media::audio::common::AudioFormat>* _aidl_return) {
1890 std::vector<audio_format_t> formats;
1891
1892 if (mAudioPolicyManager == NULL) {
1893 return binderStatusFromStatusT(NO_INIT);
1894 }
1895 Mutex::Autolock _l(mLock);
1896 AutoCallerClear acc;
1897 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1898 mAudioPolicyManager->getHwOffloadEncodingFormatsSupportedForA2DP(&formats)));
1899 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1900 convertContainer<std::vector<media::audio::common::AudioFormat>>(
1901 formats,
1902 legacy2aidl_audio_format_t_AudioFormat));
1903 return Status::ok();
1904 }
1905
setSurroundFormatEnabled(media::audio::common::AudioFormat audioFormatAidl,bool enabled)1906 Status AudioPolicyService::setSurroundFormatEnabled(
1907 media::audio::common::AudioFormat audioFormatAidl, bool enabled) {
1908 audio_format_t audioFormat = VALUE_OR_RETURN_BINDER_STATUS(
1909 aidl2legacy_AudioFormat_audio_format_t(audioFormatAidl));
1910 if (mAudioPolicyManager == NULL) {
1911 return binderStatusFromStatusT(NO_INIT);
1912 }
1913 Mutex::Autolock _l(mLock);
1914 AutoCallerClear acc;
1915 return binderStatusFromStatusT(
1916 mAudioPolicyManager->setSurroundFormatEnabled(audioFormat, enabled));
1917 }
1918
setAssistantUid(int32_t uidAidl)1919 Status AudioPolicyService::setAssistantUid(int32_t uidAidl)
1920 {
1921 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1922 Mutex::Autolock _l(mLock);
1923 mUidPolicy->setAssistantUid(uid);
1924 return Status::ok();
1925 }
1926
setHotwordDetectionServiceUid(int32_t uidAidl)1927 Status AudioPolicyService::setHotwordDetectionServiceUid(int32_t uidAidl)
1928 {
1929 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1930 Mutex::Autolock _l(mLock);
1931 mUidPolicy->setHotwordDetectionServiceUid(uid);
1932 return Status::ok();
1933 }
1934
setA11yServicesUids(const std::vector<int32_t> & uidsAidl)1935 Status AudioPolicyService::setA11yServicesUids(const std::vector<int32_t>& uidsAidl)
1936 {
1937 size_t size = uidsAidl.size();
1938 if (size > MAX_ITEMS_PER_LIST) {
1939 size = MAX_ITEMS_PER_LIST;
1940 }
1941 std::vector<uid_t> uids;
1942 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1943 convertRange(uidsAidl.begin(),
1944 uidsAidl.begin() + size,
1945 std::back_inserter(uids),
1946 aidl2legacy_int32_t_uid_t)));
1947 Mutex::Autolock _l(mLock);
1948 mUidPolicy->setA11yUids(uids);
1949 return Status::ok();
1950 }
1951
setCurrentImeUid(int32_t uidAidl)1952 Status AudioPolicyService::setCurrentImeUid(int32_t uidAidl)
1953 {
1954 uid_t uid = VALUE_OR_RETURN_BINDER_STATUS(aidl2legacy_int32_t_uid_t(uidAidl));
1955 Mutex::Autolock _l(mLock);
1956 mUidPolicy->setCurrentImeUid(uid);
1957 return Status::ok();
1958 }
1959
isHapticPlaybackSupported(bool * _aidl_return)1960 Status AudioPolicyService::isHapticPlaybackSupported(bool* _aidl_return)
1961 {
1962 if (mAudioPolicyManager == NULL) {
1963 return binderStatusFromStatusT(NO_INIT);
1964 }
1965 Mutex::Autolock _l(mLock);
1966 AutoCallerClear acc;
1967 *_aidl_return = mAudioPolicyManager->isHapticPlaybackSupported();
1968 return Status::ok();
1969 }
1970
listAudioProductStrategies(std::vector<media::AudioProductStrategy> * _aidl_return)1971 Status AudioPolicyService::listAudioProductStrategies(
1972 std::vector<media::AudioProductStrategy>* _aidl_return) {
1973 AudioProductStrategyVector strategies;
1974
1975 if (mAudioPolicyManager == NULL) {
1976 return binderStatusFromStatusT(NO_INIT);
1977 }
1978 Mutex::Autolock _l(mLock);
1979 RETURN_IF_BINDER_ERROR(
1980 binderStatusFromStatusT(mAudioPolicyManager->listAudioProductStrategies(strategies)));
1981 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
1982 convertContainer<std::vector<media::AudioProductStrategy>>(
1983 strategies,
1984 legacy2aidl_AudioProductStrategy));
1985 return Status::ok();
1986 }
1987
getProductStrategyFromAudioAttributes(const media::AudioAttributesEx & aaAidl,bool fallbackOnDefault,int32_t * _aidl_return)1988 Status AudioPolicyService::getProductStrategyFromAudioAttributes(
1989 const media::AudioAttributesEx& aaAidl, bool fallbackOnDefault, int32_t* _aidl_return) {
1990 AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
1991 aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
1992 product_strategy_t productStrategy;
1993
1994 if (mAudioPolicyManager == NULL) {
1995 return binderStatusFromStatusT(NO_INIT);
1996 }
1997 Mutex::Autolock _l(mLock);
1998 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
1999 mAudioPolicyManager->getProductStrategyFromAudioAttributes(
2000 aa, productStrategy, fallbackOnDefault)));
2001 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2002 legacy2aidl_product_strategy_t_int32_t(productStrategy));
2003 return Status::ok();
2004 }
2005
listAudioVolumeGroups(std::vector<media::AudioVolumeGroup> * _aidl_return)2006 Status AudioPolicyService::listAudioVolumeGroups(std::vector<media::AudioVolumeGroup>* _aidl_return)
2007 {
2008 AudioVolumeGroupVector groups;
2009 if (mAudioPolicyManager == NULL) {
2010 return binderStatusFromStatusT(NO_INIT);
2011 }
2012 Mutex::Autolock _l(mLock);
2013 RETURN_IF_BINDER_ERROR(
2014 binderStatusFromStatusT(mAudioPolicyManager->listAudioVolumeGroups(groups)));
2015 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2016 convertContainer<std::vector<media::AudioVolumeGroup>>(groups,
2017 legacy2aidl_AudioVolumeGroup));
2018 return Status::ok();
2019 }
2020
getVolumeGroupFromAudioAttributes(const media::AudioAttributesEx & aaAidl,bool fallbackOnDefault,int32_t * _aidl_return)2021 Status AudioPolicyService::getVolumeGroupFromAudioAttributes(
2022 const media::AudioAttributesEx& aaAidl, bool fallbackOnDefault, int32_t* _aidl_return) {
2023 AudioAttributes aa = VALUE_OR_RETURN_BINDER_STATUS(
2024 aidl2legacy_AudioAttributesEx_AudioAttributes(aaAidl));
2025 volume_group_t volumeGroup;
2026
2027 if (mAudioPolicyManager == NULL) {
2028 return binderStatusFromStatusT(NO_INIT);
2029 }
2030 Mutex::Autolock _l(mLock);
2031 RETURN_IF_BINDER_ERROR(
2032 binderStatusFromStatusT(
2033 mAudioPolicyManager->getVolumeGroupFromAudioAttributes(
2034 aa, volumeGroup, fallbackOnDefault)));
2035 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(legacy2aidl_volume_group_t_int32_t(volumeGroup));
2036 return Status::ok();
2037 }
2038
setRttEnabled(bool enabled)2039 Status AudioPolicyService::setRttEnabled(bool enabled)
2040 {
2041 Mutex::Autolock _l(mLock);
2042 mUidPolicy->setRttEnabled(enabled);
2043 return Status::ok();
2044 }
2045
isCallScreenModeSupported(bool * _aidl_return)2046 Status AudioPolicyService::isCallScreenModeSupported(bool* _aidl_return)
2047 {
2048 if (mAudioPolicyManager == NULL) {
2049 return binderStatusFromStatusT(NO_INIT);
2050 }
2051 Mutex::Autolock _l(mLock);
2052 AutoCallerClear acc;
2053 *_aidl_return = mAudioPolicyManager->isCallScreenModeSupported();
2054 return Status::ok();
2055 }
2056
setDevicesRoleForStrategy(int32_t strategyAidl,media::DeviceRole roleAidl,const std::vector<media::AudioDevice> & devicesAidl)2057 Status AudioPolicyService::setDevicesRoleForStrategy(
2058 int32_t strategyAidl,
2059 media::DeviceRole roleAidl,
2060 const std::vector<media::AudioDevice>& devicesAidl) {
2061 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2062 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2063 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2064 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2065 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2066 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2067 aidl2legacy_AudioDeviceTypeAddress));
2068
2069 if (mAudioPolicyManager == NULL) {
2070 return binderStatusFromStatusT(NO_INIT);
2071 }
2072 Mutex::Autolock _l(mLock);
2073 status_t status = mAudioPolicyManager->setDevicesRoleForStrategy(strategy, role, devices);
2074 if (status == NO_ERROR) {
2075 onCheckSpatializer_l();
2076 }
2077 return binderStatusFromStatusT(status);
2078 }
2079
removeDevicesRoleForStrategy(int32_t strategyAidl,media::DeviceRole roleAidl)2080 Status AudioPolicyService::removeDevicesRoleForStrategy(int32_t strategyAidl,
2081 media::DeviceRole roleAidl) {
2082 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2083 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2084 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2085 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2086 if (mAudioPolicyManager == NULL) {
2087 return binderStatusFromStatusT(NO_INIT);
2088 }
2089 Mutex::Autolock _l(mLock);
2090 status_t status = mAudioPolicyManager->removeDevicesRoleForStrategy(strategy, role);
2091 if (status == NO_ERROR) {
2092 onCheckSpatializer_l();
2093 }
2094 return binderStatusFromStatusT(status);
2095 }
2096
getDevicesForRoleAndStrategy(int32_t strategyAidl,media::DeviceRole roleAidl,std::vector<media::AudioDevice> * _aidl_return)2097 Status AudioPolicyService::getDevicesForRoleAndStrategy(
2098 int32_t strategyAidl,
2099 media::DeviceRole roleAidl,
2100 std::vector<media::AudioDevice>* _aidl_return) {
2101 product_strategy_t strategy = VALUE_OR_RETURN_BINDER_STATUS(
2102 aidl2legacy_int32_t_product_strategy_t(strategyAidl));
2103 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2104 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2105 AudioDeviceTypeAddrVector devices;
2106
2107 if (mAudioPolicyManager == NULL) {
2108 return binderStatusFromStatusT(NO_INIT);
2109 }
2110 Mutex::Autolock _l(mLock);
2111 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2112 mAudioPolicyManager->getDevicesForRoleAndStrategy(strategy, role, devices)));
2113 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2114 convertContainer<std::vector<media::AudioDevice>>(devices,
2115 legacy2aidl_AudioDeviceTypeAddress));
2116 return Status::ok();
2117 }
2118
registerSoundTriggerCaptureStateListener(const sp<media::ICaptureStateListener> & listener,bool * _aidl_return)2119 Status AudioPolicyService::registerSoundTriggerCaptureStateListener(
2120 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) {
2121 *_aidl_return = mCaptureStateNotifier.RegisterListener(listener);
2122 return Status::ok();
2123 }
2124
setDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,media::DeviceRole roleAidl,const std::vector<media::AudioDevice> & devicesAidl)2125 Status AudioPolicyService::setDevicesRoleForCapturePreset(
2126 media::AudioSourceType audioSourceAidl,
2127 media::DeviceRole roleAidl,
2128 const std::vector<media::AudioDevice>& devicesAidl) {
2129 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2130 aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
2131 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2132 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2133 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2134 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2135 aidl2legacy_AudioDeviceTypeAddress));
2136
2137 if (mAudioPolicyManager == nullptr) {
2138 return binderStatusFromStatusT(NO_INIT);
2139 }
2140 Mutex::Autolock _l(mLock);
2141 return binderStatusFromStatusT(
2142 mAudioPolicyManager->setDevicesRoleForCapturePreset(audioSource, role, devices));
2143 }
2144
addDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,media::DeviceRole roleAidl,const std::vector<media::AudioDevice> & devicesAidl)2145 Status AudioPolicyService::addDevicesRoleForCapturePreset(
2146 media::AudioSourceType audioSourceAidl,
2147 media::DeviceRole roleAidl,
2148 const std::vector<media::AudioDevice>& devicesAidl) {
2149 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2150 aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
2151 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2152 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2153 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2154 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2155 aidl2legacy_AudioDeviceTypeAddress));
2156
2157 if (mAudioPolicyManager == nullptr) {
2158 return binderStatusFromStatusT(NO_INIT);
2159 }
2160 Mutex::Autolock _l(mLock);
2161 return binderStatusFromStatusT(
2162 mAudioPolicyManager->addDevicesRoleForCapturePreset(audioSource, role, devices));
2163 }
2164
removeDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,media::DeviceRole roleAidl,const std::vector<media::AudioDevice> & devicesAidl)2165 Status AudioPolicyService::removeDevicesRoleForCapturePreset(
2166 media::AudioSourceType audioSourceAidl,
2167 media::DeviceRole roleAidl,
2168 const std::vector<media::AudioDevice>& devicesAidl) {
2169 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2170 aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
2171 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2172 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2173 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2174 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2175 aidl2legacy_AudioDeviceTypeAddress));
2176
2177 if (mAudioPolicyManager == nullptr) {
2178 return binderStatusFromStatusT(NO_INIT);
2179 }
2180 Mutex::Autolock _l(mLock);
2181 return binderStatusFromStatusT(
2182 mAudioPolicyManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
2183 }
2184
clearDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,media::DeviceRole roleAidl)2185 Status AudioPolicyService::clearDevicesRoleForCapturePreset(media::AudioSourceType audioSourceAidl,
2186 media::DeviceRole roleAidl) {
2187 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2188 aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
2189 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2190 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2191
2192 if (mAudioPolicyManager == nullptr) {
2193 return binderStatusFromStatusT(NO_INIT);
2194 }
2195 Mutex::Autolock _l(mLock);
2196 return binderStatusFromStatusT(
2197 mAudioPolicyManager->clearDevicesRoleForCapturePreset(audioSource, role));
2198 }
2199
getDevicesForRoleAndCapturePreset(media::AudioSourceType audioSourceAidl,media::DeviceRole roleAidl,std::vector<media::AudioDevice> * _aidl_return)2200 Status AudioPolicyService::getDevicesForRoleAndCapturePreset(
2201 media::AudioSourceType audioSourceAidl,
2202 media::DeviceRole roleAidl,
2203 std::vector<media::AudioDevice>* _aidl_return) {
2204 audio_source_t audioSource = VALUE_OR_RETURN_BINDER_STATUS(
2205 aidl2legacy_AudioSourceType_audio_source_t(audioSourceAidl));
2206 device_role_t role = VALUE_OR_RETURN_BINDER_STATUS(
2207 aidl2legacy_DeviceRole_device_role_t(roleAidl));
2208 AudioDeviceTypeAddrVector devices;
2209
2210 if (mAudioPolicyManager == nullptr) {
2211 return binderStatusFromStatusT(NO_INIT);
2212 }
2213 Mutex::Autolock _l(mLock);
2214 RETURN_IF_BINDER_ERROR(binderStatusFromStatusT(
2215 mAudioPolicyManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices)));
2216 *_aidl_return = VALUE_OR_RETURN_BINDER_STATUS(
2217 convertContainer<std::vector<media::AudioDevice>>(devices,
2218 legacy2aidl_AudioDeviceTypeAddress));
2219 return Status::ok();
2220 }
2221
getSpatializer(const sp<media::INativeSpatializerCallback> & callback,media::GetSpatializerResponse * _aidl_return)2222 Status AudioPolicyService::getSpatializer(
2223 const sp<media::INativeSpatializerCallback>& callback,
2224 media::GetSpatializerResponse* _aidl_return) {
2225 _aidl_return->spatializer = nullptr;
2226 if (callback == nullptr) {
2227 return binderStatusFromStatusT(BAD_VALUE);
2228 }
2229 if (mSpatializer != nullptr) {
2230 RETURN_IF_BINDER_ERROR(
2231 binderStatusFromStatusT(mSpatializer->registerCallback(callback)));
2232 _aidl_return->spatializer = mSpatializer;
2233 }
2234 return Status::ok();
2235 }
2236
canBeSpatialized(const std::optional<media::AudioAttributesInternal> & attrAidl,const std::optional<media::AudioConfig> & configAidl,const std::vector<media::AudioDevice> & devicesAidl,bool * _aidl_return)2237 Status AudioPolicyService::canBeSpatialized(
2238 const std::optional<media::AudioAttributesInternal>& attrAidl,
2239 const std::optional<media::AudioConfig>& configAidl,
2240 const std::vector<media::AudioDevice>& devicesAidl,
2241 bool* _aidl_return) {
2242 if (mAudioPolicyManager == nullptr) {
2243 return binderStatusFromStatusT(NO_INIT);
2244 }
2245 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
2246 if (attrAidl.has_value()) {
2247 attr = VALUE_OR_RETURN_BINDER_STATUS(
2248 aidl2legacy_AudioAttributesInternal_audio_attributes_t(attrAidl.value()));
2249 }
2250 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
2251 if (configAidl.has_value()) {
2252 config = VALUE_OR_RETURN_BINDER_STATUS(
2253 aidl2legacy_AudioConfig_audio_config_t(configAidl.value()));
2254 }
2255 AudioDeviceTypeAddrVector devices = VALUE_OR_RETURN_BINDER_STATUS(
2256 convertContainer<AudioDeviceTypeAddrVector>(devicesAidl,
2257 aidl2legacy_AudioDeviceTypeAddress));
2258
2259 Mutex::Autolock _l(mLock);
2260 *_aidl_return = mAudioPolicyManager->canBeSpatialized(&attr, &config, devices);
2261 return Status::ok();
2262 }
2263
2264 } // namespace android
2265