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