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