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