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 "AudioPolicyService"
18 //#define LOG_NDEBUG 0
19
20 #include "Configuration.h"
21 #undef __STRICT_ANSI__
22 #define __STDINT_LIMITS
23 #define __STDC_LIMIT_MACROS
24 #include <stdint.h>
25 #include <sys/time.h>
26
27 #include <audio_utils/clock.h>
28 #include <binder/IServiceManager.h>
29 #include <utils/Log.h>
30 #include <cutils/properties.h>
31 #include <binder/IPCThreadState.h>
32 #include <binder/ActivityManager.h>
33 #include <binder/PermissionController.h>
34 #include <binder/IResultReceiver.h>
35 #include <utils/String16.h>
36 #include <utils/threads.h>
37 #include "AudioPolicyService.h"
38 #include <hardware_legacy/power.h>
39 #include <media/AudioEffect.h>
40 #include <media/AudioParameter.h>
41 #include <mediautils/ServiceUtilities.h>
42 #include <sensorprivacy/SensorPrivacyManager.h>
43
44 #include <system/audio.h>
45 #include <system/audio_policy.h>
46
47 namespace android {
48
49 static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
50 static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
51
52 static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
53
54 static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
55
56 static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
57
58 // ----------------------------------------------------------------------------
59
AudioPolicyService()60 AudioPolicyService::AudioPolicyService()
61 : BnAudioPolicyService(), mpAudioPolicyDev(NULL), mpAudioPolicy(NULL),
62 mAudioPolicyManager(NULL), mAudioPolicyClient(NULL), mPhoneState(AUDIO_MODE_INVALID)
63 {
64 }
65
onFirstRef()66 void AudioPolicyService::onFirstRef()
67 {
68 {
69 Mutex::Autolock _l(mLock);
70
71 // start audio commands thread
72 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
73 // start output activity command thread
74 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
75
76 mAudioPolicyClient = new AudioPolicyClient(this);
77 mAudioPolicyManager = createAudioPolicyManager(mAudioPolicyClient);
78 }
79 // load audio processing modules
80 sp<AudioPolicyEffects>audioPolicyEffects = new AudioPolicyEffects();
81 {
82 Mutex::Autolock _l(mLock);
83 mAudioPolicyEffects = audioPolicyEffects;
84 }
85
86 mUidPolicy = new UidPolicy(this);
87 mUidPolicy->registerSelf();
88
89 mSensorPrivacyPolicy = new SensorPrivacyPolicy(this);
90 mSensorPrivacyPolicy->registerSelf();
91 }
92
~AudioPolicyService()93 AudioPolicyService::~AudioPolicyService()
94 {
95 mAudioCommandThread->exit();
96 mOutputCommandThread->exit();
97
98 destroyAudioPolicyManager(mAudioPolicyManager);
99 delete mAudioPolicyClient;
100
101 mNotificationClients.clear();
102 mAudioPolicyEffects.clear();
103
104 mUidPolicy->unregisterSelf();
105 mUidPolicy.clear();
106
107 mSensorPrivacyPolicy->unregisterSelf();
108 mSensorPrivacyPolicy.clear();
109 }
110
111 // A notification client is always registered by AudioSystem when the client process
112 // connects to AudioPolicyService.
registerClient(const sp<IAudioPolicyServiceClient> & client)113 void AudioPolicyService::registerClient(const sp<IAudioPolicyServiceClient>& client)
114 {
115 if (client == 0) {
116 ALOGW("%s got NULL client", __FUNCTION__);
117 return;
118 }
119 Mutex::Autolock _l(mNotificationClientsLock);
120
121 uid_t uid = IPCThreadState::self()->getCallingUid();
122 pid_t pid = IPCThreadState::self()->getCallingPid();
123 int64_t token = ((int64_t)uid<<32) | pid;
124
125 if (mNotificationClients.indexOfKey(token) < 0) {
126 sp<NotificationClient> notificationClient = new NotificationClient(this,
127 client,
128 uid,
129 pid);
130 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
131
132 mNotificationClients.add(token, notificationClient);
133
134 sp<IBinder> binder = IInterface::asBinder(client);
135 binder->linkToDeath(notificationClient);
136 }
137 }
138
setAudioPortCallbacksEnabled(bool enabled)139 void AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
140 {
141 Mutex::Autolock _l(mNotificationClientsLock);
142
143 uid_t uid = IPCThreadState::self()->getCallingUid();
144 pid_t pid = IPCThreadState::self()->getCallingPid();
145 int64_t token = ((int64_t)uid<<32) | pid;
146
147 if (mNotificationClients.indexOfKey(token) < 0) {
148 return;
149 }
150 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
151 }
152
setAudioVolumeGroupCallbacksEnabled(bool enabled)153 void AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
154 {
155 Mutex::Autolock _l(mNotificationClientsLock);
156
157 uid_t uid = IPCThreadState::self()->getCallingUid();
158 pid_t pid = IPCThreadState::self()->getCallingPid();
159 int64_t token = ((int64_t)uid<<32) | pid;
160
161 if (mNotificationClients.indexOfKey(token) < 0) {
162 return;
163 }
164 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
165 }
166
167 // removeNotificationClient() is called when the client process dies.
removeNotificationClient(uid_t uid,pid_t pid)168 void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
169 {
170 {
171 Mutex::Autolock _l(mNotificationClientsLock);
172 int64_t token = ((int64_t)uid<<32) | pid;
173 mNotificationClients.removeItem(token);
174 }
175 {
176 Mutex::Autolock _l(mLock);
177 bool hasSameUid = false;
178 for (size_t i = 0; i < mNotificationClients.size(); i++) {
179 if (mNotificationClients.valueAt(i)->uid() == uid) {
180 hasSameUid = true;
181 break;
182 }
183 }
184 if (mAudioPolicyManager && !hasSameUid) {
185 // called from binder death notification: no need to clear caller identity
186 mAudioPolicyManager->releaseResourcesForUid(uid);
187 }
188 }
189 }
190
onAudioPortListUpdate()191 void AudioPolicyService::onAudioPortListUpdate()
192 {
193 mOutputCommandThread->updateAudioPortListCommand();
194 }
195
doOnAudioPortListUpdate()196 void AudioPolicyService::doOnAudioPortListUpdate()
197 {
198 Mutex::Autolock _l(mNotificationClientsLock);
199 for (size_t i = 0; i < mNotificationClients.size(); i++) {
200 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
201 }
202 }
203
onAudioPatchListUpdate()204 void AudioPolicyService::onAudioPatchListUpdate()
205 {
206 mOutputCommandThread->updateAudioPatchListCommand();
207 }
208
doOnAudioPatchListUpdate()209 void AudioPolicyService::doOnAudioPatchListUpdate()
210 {
211 Mutex::Autolock _l(mNotificationClientsLock);
212 for (size_t i = 0; i < mNotificationClients.size(); i++) {
213 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
214 }
215 }
216
onAudioVolumeGroupChanged(volume_group_t group,int flags)217 void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
218 {
219 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
220 }
221
doOnAudioVolumeGroupChanged(volume_group_t group,int flags)222 void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
223 {
224 Mutex::Autolock _l(mNotificationClientsLock);
225 for (size_t i = 0; i < mNotificationClients.size(); i++) {
226 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
227 }
228 }
229
onDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)230 void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
231 {
232 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
233 regId.string(), state);
234 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
235 }
236
doOnDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)237 void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
238 {
239 Mutex::Autolock _l(mNotificationClientsLock);
240 for (size_t i = 0; i < mNotificationClients.size(); i++) {
241 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
242 }
243 }
244
onRecordingConfigurationUpdate(int event,const record_client_info_t * clientInfo,const audio_config_base_t * clientConfig,std::vector<effect_descriptor_t> clientEffects,const audio_config_base_t * deviceConfig,std::vector<effect_descriptor_t> effects,audio_patch_handle_t patchHandle,audio_source_t source)245 void AudioPolicyService::onRecordingConfigurationUpdate(
246 int event,
247 const record_client_info_t *clientInfo,
248 const audio_config_base_t *clientConfig,
249 std::vector<effect_descriptor_t> clientEffects,
250 const audio_config_base_t *deviceConfig,
251 std::vector<effect_descriptor_t> effects,
252 audio_patch_handle_t patchHandle,
253 audio_source_t source)
254 {
255 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
256 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
257 }
258
doOnRecordingConfigurationUpdate(int event,const record_client_info_t * clientInfo,const audio_config_base_t * clientConfig,std::vector<effect_descriptor_t> clientEffects,const audio_config_base_t * deviceConfig,std::vector<effect_descriptor_t> effects,audio_patch_handle_t patchHandle,audio_source_t source)259 void AudioPolicyService::doOnRecordingConfigurationUpdate(
260 int event,
261 const record_client_info_t *clientInfo,
262 const audio_config_base_t *clientConfig,
263 std::vector<effect_descriptor_t> clientEffects,
264 const audio_config_base_t *deviceConfig,
265 std::vector<effect_descriptor_t> effects,
266 audio_patch_handle_t patchHandle,
267 audio_source_t source)
268 {
269 Mutex::Autolock _l(mNotificationClientsLock);
270 for (size_t i = 0; i < mNotificationClients.size(); i++) {
271 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
272 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
273 }
274 }
275
clientCreateAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)276 status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
277 audio_patch_handle_t *handle,
278 int delayMs)
279 {
280 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
281 }
282
clientReleaseAudioPatch(audio_patch_handle_t handle,int delayMs)283 status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
284 int delayMs)
285 {
286 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
287 }
288
clientSetAudioPortConfig(const struct audio_port_config * config,int delayMs)289 status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
290 int delayMs)
291 {
292 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
293 }
294
NotificationClient(const sp<AudioPolicyService> & service,const sp<IAudioPolicyServiceClient> & client,uid_t uid,pid_t pid)295 AudioPolicyService::NotificationClient::NotificationClient(const sp<AudioPolicyService>& service,
296 const sp<IAudioPolicyServiceClient>& client,
297 uid_t uid,
298 pid_t pid)
299 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
300 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
301 {
302 }
303
~NotificationClient()304 AudioPolicyService::NotificationClient::~NotificationClient()
305 {
306 }
307
binderDied(const wp<IBinder> & who __unused)308 void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
309 {
310 sp<NotificationClient> keep(this);
311 sp<AudioPolicyService> service = mService.promote();
312 if (service != 0) {
313 service->removeNotificationClient(mUid, mPid);
314 }
315 }
316
onAudioPortListUpdate()317 void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
318 {
319 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
320 mAudioPolicyServiceClient->onAudioPortListUpdate();
321 }
322 }
323
onAudioPatchListUpdate()324 void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
325 {
326 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
327 mAudioPolicyServiceClient->onAudioPatchListUpdate();
328 }
329 }
330
onAudioVolumeGroupChanged(volume_group_t group,int flags)331 void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
332 int flags)
333 {
334 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
335 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
336 }
337 }
338
339
onDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)340 void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
341 const String8& regId, int32_t state)
342 {
343 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
344 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(regId, state);
345 }
346 }
347
onRecordingConfigurationUpdate(int event,const record_client_info_t * clientInfo,const audio_config_base_t * clientConfig,std::vector<effect_descriptor_t> clientEffects,const audio_config_base_t * deviceConfig,std::vector<effect_descriptor_t> effects,audio_patch_handle_t patchHandle,audio_source_t source)348 void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
349 int event,
350 const record_client_info_t *clientInfo,
351 const audio_config_base_t *clientConfig,
352 std::vector<effect_descriptor_t> clientEffects,
353 const audio_config_base_t *deviceConfig,
354 std::vector<effect_descriptor_t> effects,
355 audio_patch_handle_t patchHandle,
356 audio_source_t source)
357 {
358 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
359 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(event, clientInfo,
360 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
361 }
362 }
363
setAudioPortCallbacksEnabled(bool enabled)364 void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
365 {
366 mAudioPortCallbacksEnabled = enabled;
367 }
368
setAudioVolumeGroupCallbacksEnabled(bool enabled)369 void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
370 {
371 mAudioVolumeGroupCallbacksEnabled = enabled;
372 }
373
binderDied(const wp<IBinder> & who)374 void AudioPolicyService::binderDied(const wp<IBinder>& who) {
375 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
376 IPCThreadState::self()->getCallingPid());
377 }
378
dumpTryLock(Mutex & mutex)379 static bool dumpTryLock(Mutex& mutex)
380 {
381 status_t err = mutex.timedLock(kDumpLockTimeoutNs);
382 return err == NO_ERROR;
383 }
384
dumpInternals(int fd)385 status_t AudioPolicyService::dumpInternals(int fd)
386 {
387 const size_t SIZE = 256;
388 char buffer[SIZE];
389 String8 result;
390
391 snprintf(buffer, SIZE, "AudioPolicyManager: %p\n", mAudioPolicyManager);
392 result.append(buffer);
393 snprintf(buffer, SIZE, "Command Thread: %p\n", mAudioCommandThread.get());
394 result.append(buffer);
395
396 write(fd, result.string(), result.size());
397 return NO_ERROR;
398 }
399
updateUidStates()400 void AudioPolicyService::updateUidStates()
401 {
402 Mutex::Autolock _l(mLock);
403 updateUidStates_l();
404 }
405
updateUidStates_l()406 void AudioPolicyService::updateUidStates_l()
407 {
408 // Go over all active clients and allow capture (does not force silence) in the
409 // following cases:
410 // Another client in the same UID has already been allowed to capture
411 // OR The client is the assistant
412 // AND an accessibility service is on TOP or a RTT call is active
413 // AND the source is VOICE_RECOGNITION or HOTWORD
414 // OR uses VOICE_RECOGNITION AND is on TOP
415 // OR uses HOTWORD
416 // AND there is no active privacy sensitive capture or call
417 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
418 // OR The client is an accessibility service
419 // AND is on TOP
420 // AND the source is VOICE_RECOGNITION or HOTWORD
421 // OR the client source is virtual (remote submix, call audio TX or RX...)
422 // OR Any client
423 // AND The assistant is not on TOP
424 // AND is on TOP or latest started
425 // AND there is no active privacy sensitive capture or call
426 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
427
428 sp<AudioRecordClient> topActive;
429 sp<AudioRecordClient> latestActive;
430 sp<AudioRecordClient> latestSensitiveActive;
431
432 nsecs_t topStartNs = 0;
433 nsecs_t latestStartNs = 0;
434 nsecs_t latestSensitiveStartNs = 0;
435 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
436 bool isAssistantOnTop = false;
437 bool isSensitiveActive = false;
438 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
439 bool rttCallActive =
440 (mPhoneState == AUDIO_MODE_IN_CALL || mPhoneState == AUDIO_MODE_IN_COMMUNICATION)
441 && mUidPolicy->isRttEnabled();
442
443 // if Sensor Privacy is enabled then all recordings should be silenced.
444 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
445 silenceAllRecordings_l();
446 return;
447 }
448
449 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
450 sp<AudioRecordClient> current = mAudioRecordClients[i];
451 if (!current->active) {
452 continue;
453 }
454
455 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(current->uid));
456 // clients which app is in IDLE state are not eligible for top active or
457 // latest active
458 if (appState == APP_STATE_IDLE) {
459 continue;
460 }
461
462 if (appState == APP_STATE_TOP) {
463 if (current->startTimeNs > topStartNs) {
464 topActive = current;
465 topStartNs = current->startTimeNs;
466 }
467 if (mUidPolicy->isAssistantUid(current->uid)) {
468 isAssistantOnTop = true;
469 }
470 }
471 if (current->startTimeNs > latestStartNs) {
472 latestActive = current;
473 latestStartNs = current->startTimeNs;
474 }
475 if (isPrivacySensitiveSource(current->attributes.source)) {
476 if (current->startTimeNs > latestSensitiveStartNs) {
477 latestSensitiveActive = current;
478 latestSensitiveStartNs = current->startTimeNs;
479 }
480 isSensitiveActive = true;
481 }
482 }
483
484 // if no active client with UI on Top, consider latest active as top
485 if (topActive == nullptr) {
486 topActive = latestActive;
487 }
488
489 std::vector<uid_t> enabledUids;
490
491 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
492 sp<AudioRecordClient> current = mAudioRecordClients[i];
493 if (!current->active) {
494 continue;
495 }
496
497 // keep capture allowed if another client with the same UID has already
498 // been allowed to capture
499 if (std::find(enabledUids.begin(), enabledUids.end(), current->uid)
500 != enabledUids.end()) {
501 continue;
502 }
503
504 audio_source_t source = current->attributes.source;
505 bool isTopOrLatestActive = topActive == nullptr ? false : current->uid == topActive->uid;
506 bool isLatestSensitive = latestSensitiveActive == nullptr ?
507 false : current->uid == latestSensitiveActive->uid;
508
509 // By default allow capture if:
510 // The assistant is not on TOP
511 // AND is on TOP or latest started
512 // AND there is no active privacy sensitive capture or call
513 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
514 bool allowCapture = !isAssistantOnTop
515 && ((isTopOrLatestActive && !isLatestSensitive) || isLatestSensitive)
516 && !(isSensitiveActive && !(isLatestSensitive || current->canCaptureOutput))
517 && !(isInCall && !current->canCaptureOutput);
518
519 if (isVirtualSource(source)) {
520 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
521 allowCapture = true;
522 } else if (mUidPolicy->isAssistantUid(current->uid)) {
523 // For assistant allow capture if:
524 // An accessibility service is on TOP or a RTT call is active
525 // AND the source is VOICE_RECOGNITION or HOTWORD
526 // OR is on TOP AND uses VOICE_RECOGNITION
527 // OR uses HOTWORD
528 // AND there is no active privacy sensitive capture or call
529 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
530 if (isA11yOnTop || rttCallActive) {
531 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
532 allowCapture = true;
533 }
534 } else {
535 if (((isAssistantOnTop && source == AUDIO_SOURCE_VOICE_RECOGNITION) ||
536 source == AUDIO_SOURCE_HOTWORD) &&
537 (!(isSensitiveActive || isInCall) || current->canCaptureOutput)) {
538 allowCapture = true;
539 }
540 }
541 } else if (mUidPolicy->isA11yUid(current->uid)) {
542 // For accessibility service allow capture if:
543 // Is on TOP
544 // AND the source is VOICE_RECOGNITION or HOTWORD
545 if (isA11yOnTop &&
546 (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD)) {
547 allowCapture = true;
548 }
549 }
550 setAppState_l(current->uid,
551 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(current->uid)) :
552 APP_STATE_IDLE);
553 if (allowCapture) {
554 enabledUids.push_back(current->uid);
555 }
556 }
557 }
558
silenceAllRecordings_l()559 void AudioPolicyService::silenceAllRecordings_l() {
560 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
561 sp<AudioRecordClient> current = mAudioRecordClients[i];
562 if (!isVirtualSource(current->attributes.source)) {
563 setAppState_l(current->uid, APP_STATE_IDLE);
564 }
565 }
566 }
567
568 /* static */
apmStatFromAmState(int amState)569 app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
570
571 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
572 return APP_STATE_IDLE;
573 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
574 // include persistent services
575 return APP_STATE_TOP;
576 }
577 return APP_STATE_FOREGROUND;
578 }
579
580 /* static */
isPrivacySensitiveSource(audio_source_t source)581 bool AudioPolicyService::isPrivacySensitiveSource(audio_source_t source)
582 {
583 switch (source) {
584 case AUDIO_SOURCE_CAMCORDER:
585 case AUDIO_SOURCE_VOICE_COMMUNICATION:
586 return true;
587 default:
588 break;
589 }
590 return false;
591 }
592
593 /* static */
isVirtualSource(audio_source_t source)594 bool AudioPolicyService::isVirtualSource(audio_source_t source)
595 {
596 switch (source) {
597 case AUDIO_SOURCE_VOICE_UPLINK:
598 case AUDIO_SOURCE_VOICE_DOWNLINK:
599 case AUDIO_SOURCE_VOICE_CALL:
600 case AUDIO_SOURCE_REMOTE_SUBMIX:
601 case AUDIO_SOURCE_FM_TUNER:
602 return true;
603 default:
604 break;
605 }
606 return false;
607 }
608
setAppState_l(uid_t uid,app_state_t state)609 void AudioPolicyService::setAppState_l(uid_t uid, app_state_t state)
610 {
611 AutoCallerClear acc;
612
613 if (mAudioPolicyManager) {
614 mAudioPolicyManager->setAppState(uid, state);
615 }
616 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
617 if (af) {
618 bool silenced = state == APP_STATE_IDLE;
619 af->setRecordSilenced(uid, silenced);
620 }
621 }
622
dump(int fd,const Vector<String16> & args __unused)623 status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
624 {
625 if (!dumpAllowed()) {
626 dumpPermissionDenial(fd);
627 } else {
628 bool locked = dumpTryLock(mLock);
629 if (!locked) {
630 String8 result(kDeadlockedString);
631 write(fd, result.string(), result.size());
632 }
633
634 dumpInternals(fd);
635 if (mAudioCommandThread != 0) {
636 mAudioCommandThread->dump(fd);
637 }
638
639 if (mAudioPolicyManager) {
640 mAudioPolicyManager->dump(fd);
641 }
642
643 mPackageManager.dump(fd);
644
645 if (locked) mLock.unlock();
646 }
647 return NO_ERROR;
648 }
649
dumpPermissionDenial(int fd)650 status_t AudioPolicyService::dumpPermissionDenial(int fd)
651 {
652 const size_t SIZE = 256;
653 char buffer[SIZE];
654 String8 result;
655 snprintf(buffer, SIZE, "Permission Denial: "
656 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
657 IPCThreadState::self()->getCallingPid(),
658 IPCThreadState::self()->getCallingUid());
659 result.append(buffer);
660 write(fd, result.string(), result.size());
661 return NO_ERROR;
662 }
663
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)664 status_t AudioPolicyService::onTransact(
665 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
666 switch (code) {
667 case SHELL_COMMAND_TRANSACTION: {
668 int in = data.readFileDescriptor();
669 int out = data.readFileDescriptor();
670 int err = data.readFileDescriptor();
671 int argc = data.readInt32();
672 Vector<String16> args;
673 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
674 args.add(data.readString16());
675 }
676 sp<IBinder> unusedCallback;
677 sp<IResultReceiver> resultReceiver;
678 status_t status;
679 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
680 return status;
681 }
682 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
683 return status;
684 }
685 status = shellCommand(in, out, err, args);
686 if (resultReceiver != nullptr) {
687 resultReceiver->send(status);
688 }
689 return NO_ERROR;
690 }
691 }
692
693 return BnAudioPolicyService::onTransact(code, data, reply, flags);
694 }
695
696 // ------------------- Shell command implementation -------------------
697
698 // NOTE: This is a remote API - make sure all args are validated
shellCommand(int in,int out,int err,Vector<String16> & args)699 status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
700 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
701 return PERMISSION_DENIED;
702 }
703 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
704 return BAD_VALUE;
705 }
706 if (args.size() == 3 && args[0] == String16("set-uid-state")) {
707 return handleSetUidState(args, err);
708 } else if (args.size() == 2 && args[0] == String16("reset-uid-state")) {
709 return handleResetUidState(args, err);
710 } else if (args.size() == 2 && args[0] == String16("get-uid-state")) {
711 return handleGetUidState(args, out, err);
712 } else if (args.size() == 1 && args[0] == String16("help")) {
713 printHelp(out);
714 return NO_ERROR;
715 }
716 printHelp(err);
717 return BAD_VALUE;
718 }
719
handleSetUidState(Vector<String16> & args,int err)720 status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
721 PermissionController pc;
722 int uid = pc.getPackageUid(args[1], 0);
723 if (uid <= 0) {
724 ALOGE("Unknown package: '%s'", String8(args[1]).string());
725 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
726 return BAD_VALUE;
727 }
728 bool active = false;
729 if (args[2] == String16("active")) {
730 active = true;
731 } else if ((args[2] != String16("idle"))) {
732 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
733 return BAD_VALUE;
734 }
735 mUidPolicy->addOverrideUid(uid, active);
736 return NO_ERROR;
737 }
738
handleResetUidState(Vector<String16> & args,int err)739 status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
740 PermissionController pc;
741 int uid = pc.getPackageUid(args[1], 0);
742 if (uid < 0) {
743 ALOGE("Unknown package: '%s'", String8(args[1]).string());
744 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
745 return BAD_VALUE;
746 }
747 mUidPolicy->removeOverrideUid(uid);
748 return NO_ERROR;
749 }
750
handleGetUidState(Vector<String16> & args,int out,int err)751 status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
752 PermissionController pc;
753 int uid = pc.getPackageUid(args[1], 0);
754 if (uid < 0) {
755 ALOGE("Unknown package: '%s'", String8(args[1]).string());
756 dprintf(err, "Unknown package: '%s'\n", String8(args[1]).string());
757 return BAD_VALUE;
758 }
759 if (mUidPolicy->isUidActive(uid)) {
760 return dprintf(out, "active\n");
761 } else {
762 return dprintf(out, "idle\n");
763 }
764 }
765
printHelp(int out)766 status_t AudioPolicyService::printHelp(int out) {
767 return dprintf(out, "Audio policy service commands:\n"
768 " get-uid-state <PACKAGE> gets the uid state\n"
769 " set-uid-state <PACKAGE> <active|idle> overrides the uid state\n"
770 " reset-uid-state <PACKAGE> clears the uid state override\n"
771 " help print this message\n");
772 }
773
774 // ----------- AudioPolicyService::UidPolicy implementation ----------
775
registerSelf()776 void AudioPolicyService::UidPolicy::registerSelf() {
777 ActivityManager am;
778 am.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
779 | ActivityManager::UID_OBSERVER_IDLE
780 | ActivityManager::UID_OBSERVER_ACTIVE
781 | ActivityManager::UID_OBSERVER_PROCSTATE,
782 ActivityManager::PROCESS_STATE_UNKNOWN,
783 String16("audioserver"));
784 status_t res = am.linkToDeath(this);
785 if (!res) {
786 Mutex::Autolock _l(mLock);
787 mObserverRegistered = true;
788 } else {
789 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
790
791 am.unregisterUidObserver(this);
792 }
793 }
794
unregisterSelf()795 void AudioPolicyService::UidPolicy::unregisterSelf() {
796 ActivityManager am;
797 am.unlinkToDeath(this);
798 am.unregisterUidObserver(this);
799 Mutex::Autolock _l(mLock);
800 mObserverRegistered = false;
801 }
802
binderDied(__unused const wp<IBinder> & who)803 void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
804 Mutex::Autolock _l(mLock);
805 mCachedUids.clear();
806 mObserverRegistered = false;
807 }
808
checkRegistered()809 void AudioPolicyService::UidPolicy::checkRegistered() {
810 bool needToReregister = false;
811 {
812 Mutex::Autolock _l(mLock);
813 needToReregister = !mObserverRegistered;
814 }
815 if (needToReregister) {
816 // Looks like ActivityManager has died previously, attempt to re-register.
817 registerSelf();
818 }
819 }
820
isUidActive(uid_t uid)821 bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
822 if (isServiceUid(uid)) return true;
823 checkRegistered();
824 {
825 Mutex::Autolock _l(mLock);
826 auto overrideIter = mOverrideUids.find(uid);
827 if (overrideIter != mOverrideUids.end()) {
828 return overrideIter->second.first;
829 }
830 // In an absense of the ActivityManager, assume everything to be active.
831 if (!mObserverRegistered) return true;
832 auto cacheIter = mCachedUids.find(uid);
833 if (cacheIter != mCachedUids.end()) {
834 return cacheIter->second.first;
835 }
836 }
837 ActivityManager am;
838 bool active = am.isUidActive(uid, String16("audioserver"));
839 {
840 Mutex::Autolock _l(mLock);
841 mCachedUids.insert(std::pair<uid_t,
842 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
843 ActivityManager::PROCESS_STATE_UNKNOWN)));
844 }
845 return active;
846 }
847
getUidState(uid_t uid)848 int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
849 if (isServiceUid(uid)) {
850 return ActivityManager::PROCESS_STATE_TOP;
851 }
852 checkRegistered();
853 {
854 Mutex::Autolock _l(mLock);
855 auto overrideIter = mOverrideUids.find(uid);
856 if (overrideIter != mOverrideUids.end()) {
857 if (overrideIter->second.first) {
858 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
859 return overrideIter->second.second;
860 } else {
861 auto cacheIter = mCachedUids.find(uid);
862 if (cacheIter != mCachedUids.end()) {
863 return cacheIter->second.second;
864 }
865 }
866 }
867 return ActivityManager::PROCESS_STATE_UNKNOWN;
868 }
869 // In an absense of the ActivityManager, assume everything to be active.
870 if (!mObserverRegistered) {
871 return ActivityManager::PROCESS_STATE_TOP;
872 }
873 auto cacheIter = mCachedUids.find(uid);
874 if (cacheIter != mCachedUids.end()) {
875 if (cacheIter->second.first) {
876 return cacheIter->second.second;
877 } else {
878 return ActivityManager::PROCESS_STATE_UNKNOWN;
879 }
880 }
881 }
882 ActivityManager am;
883 bool active = am.isUidActive(uid, String16("audioserver"));
884 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
885 if (active) {
886 state = am.getUidProcessState(uid, String16("audioserver"));
887 }
888 {
889 Mutex::Autolock _l(mLock);
890 mCachedUids.insert(std::pair<uid_t,
891 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
892 }
893
894 return state;
895 }
896
onUidActive(uid_t uid)897 void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
898 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
899 }
900
onUidGone(uid_t uid,__unused bool disabled)901 void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
902 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
903 }
904
onUidIdle(uid_t uid,__unused bool disabled)905 void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
906 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
907 }
908
onUidStateChanged(uid_t uid,int32_t procState,int64_t procStateSeq __unused)909 void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
910 int32_t procState,
911 int64_t procStateSeq __unused) {
912 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
913 updateUid(&mCachedUids, uid, true, procState, true);
914 }
915 }
916
updateOverrideUid(uid_t uid,bool active,bool insert)917 void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
918 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
919 }
920
notifyService()921 void AudioPolicyService::UidPolicy::notifyService() {
922 sp<AudioPolicyService> service = mService.promote();
923 if (service != nullptr) {
924 service->updateUidStates();
925 }
926 }
927
updateUid(std::unordered_map<uid_t,std::pair<bool,int>> * uids,uid_t uid,bool active,int state,bool insert)928 void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
929 std::pair<bool, int>> *uids,
930 uid_t uid,
931 bool active,
932 int state,
933 bool insert) {
934 if (isServiceUid(uid)) {
935 return;
936 }
937 bool wasActive = isUidActive(uid);
938 int previousState = getUidState(uid);
939 {
940 Mutex::Autolock _l(mLock);
941 updateUidLocked(uids, uid, active, state, insert);
942 }
943 if (wasActive != isUidActive(uid) || state != previousState) {
944 notifyService();
945 }
946 }
947
updateUidLocked(std::unordered_map<uid_t,std::pair<bool,int>> * uids,uid_t uid,bool active,int state,bool insert)948 void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
949 std::pair<bool, int>> *uids,
950 uid_t uid,
951 bool active,
952 int state,
953 bool insert) {
954 auto it = uids->find(uid);
955 if (it != uids->end()) {
956 if (insert) {
957 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
958 it->second.first = active;
959 }
960 if (it->second.first) {
961 it->second.second = state;
962 } else {
963 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
964 }
965 } else {
966 uids->erase(it);
967 }
968 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
969 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
970 std::pair<bool, int>(active, state)));
971 }
972 }
973
isA11yOnTop()974 bool AudioPolicyService::UidPolicy::isA11yOnTop() {
975 for (const auto &uid : mCachedUids) {
976 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid.first);
977 if (it == mA11yUids.end()) {
978 continue;
979 }
980 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
981 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
982 return true;
983 }
984 }
985 return false;
986 }
987
isA11yUid(uid_t uid)988 bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
989 {
990 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
991 return it != mA11yUids.end();
992 }
993
994 // ----------- AudioPolicyService::SensorPrivacyService implementation ----------
registerSelf()995 void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
996 SensorPrivacyManager spm;
997 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
998 spm.addSensorPrivacyListener(this);
999 }
1000
unregisterSelf()1001 void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1002 SensorPrivacyManager spm;
1003 spm.removeSensorPrivacyListener(this);
1004 }
1005
isSensorPrivacyEnabled()1006 bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1007 return mSensorPrivacyEnabled;
1008 }
1009
onSensorPrivacyChanged(bool enabled)1010 binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(bool enabled) {
1011 mSensorPrivacyEnabled = enabled;
1012 sp<AudioPolicyService> service = mService.promote();
1013 if (service != nullptr) {
1014 service->updateUidStates();
1015 }
1016 return binder::Status::ok();
1017 }
1018
1019 // ----------- AudioPolicyService::AudioCommandThread implementation ----------
1020
AudioCommandThread(String8 name,const wp<AudioPolicyService> & service)1021 AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1022 const wp<AudioPolicyService>& service)
1023 : Thread(false), mName(name), mService(service)
1024 {
1025 }
1026
1027
~AudioCommandThread()1028 AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1029 {
1030 if (!mAudioCommands.isEmpty()) {
1031 release_wake_lock(mName.string());
1032 }
1033 mAudioCommands.clear();
1034 }
1035
onFirstRef()1036 void AudioPolicyService::AudioCommandThread::onFirstRef()
1037 {
1038 run(mName.string(), ANDROID_PRIORITY_AUDIO);
1039 }
1040
threadLoop()1041 bool AudioPolicyService::AudioCommandThread::threadLoop()
1042 {
1043 nsecs_t waitTime = -1;
1044
1045 mLock.lock();
1046 while (!exitPending())
1047 {
1048 sp<AudioPolicyService> svc;
1049 while (!mAudioCommands.isEmpty() && !exitPending()) {
1050 nsecs_t curTime = systemTime();
1051 // commands are sorted by increasing time stamp: execute them from index 0 and up
1052 if (mAudioCommands[0]->mTime <= curTime) {
1053 sp<AudioCommand> command = mAudioCommands[0];
1054 mAudioCommands.removeAt(0);
1055 mLastCommand = command;
1056
1057 switch (command->mCommand) {
1058 case SET_VOLUME: {
1059 VolumeData *data = (VolumeData *)command->mParam.get();
1060 ALOGV("AudioCommandThread() processing set volume stream %d, \
1061 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
1062 mLock.unlock();
1063 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1064 data->mVolume,
1065 data->mIO);
1066 mLock.lock();
1067 }break;
1068 case SET_PARAMETERS: {
1069 ParametersData *data = (ParametersData *)command->mParam.get();
1070 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
1071 data->mKeyValuePairs.string(), data->mIO);
1072 mLock.unlock();
1073 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
1074 mLock.lock();
1075 }break;
1076 case SET_VOICE_VOLUME: {
1077 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
1078 ALOGV("AudioCommandThread() processing set voice volume volume %f",
1079 data->mVolume);
1080 mLock.unlock();
1081 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
1082 mLock.lock();
1083 }break;
1084 case STOP_OUTPUT: {
1085 StopOutputData *data = (StopOutputData *)command->mParam.get();
1086 ALOGV("AudioCommandThread() processing stop output portId %d",
1087 data->mPortId);
1088 svc = mService.promote();
1089 if (svc == 0) {
1090 break;
1091 }
1092 mLock.unlock();
1093 svc->doStopOutput(data->mPortId);
1094 mLock.lock();
1095 }break;
1096 case RELEASE_OUTPUT: {
1097 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
1098 ALOGV("AudioCommandThread() processing release output portId %d",
1099 data->mPortId);
1100 svc = mService.promote();
1101 if (svc == 0) {
1102 break;
1103 }
1104 mLock.unlock();
1105 svc->doReleaseOutput(data->mPortId);
1106 mLock.lock();
1107 }break;
1108 case CREATE_AUDIO_PATCH: {
1109 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1110 ALOGV("AudioCommandThread() processing create audio patch");
1111 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1112 if (af == 0) {
1113 command->mStatus = PERMISSION_DENIED;
1114 } else {
1115 mLock.unlock();
1116 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
1117 mLock.lock();
1118 }
1119 } break;
1120 case RELEASE_AUDIO_PATCH: {
1121 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1122 ALOGV("AudioCommandThread() processing release audio patch");
1123 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1124 if (af == 0) {
1125 command->mStatus = PERMISSION_DENIED;
1126 } else {
1127 mLock.unlock();
1128 command->mStatus = af->releaseAudioPatch(data->mHandle);
1129 mLock.lock();
1130 }
1131 } break;
1132 case UPDATE_AUDIOPORT_LIST: {
1133 ALOGV("AudioCommandThread() processing update audio port list");
1134 svc = mService.promote();
1135 if (svc == 0) {
1136 break;
1137 }
1138 mLock.unlock();
1139 svc->doOnAudioPortListUpdate();
1140 mLock.lock();
1141 }break;
1142 case UPDATE_AUDIOPATCH_LIST: {
1143 ALOGV("AudioCommandThread() processing update audio patch list");
1144 svc = mService.promote();
1145 if (svc == 0) {
1146 break;
1147 }
1148 mLock.unlock();
1149 svc->doOnAudioPatchListUpdate();
1150 mLock.lock();
1151 }break;
1152 case CHANGED_AUDIOVOLUMEGROUP: {
1153 AudioVolumeGroupData *data =
1154 static_cast<AudioVolumeGroupData *>(command->mParam.get());
1155 ALOGV("AudioCommandThread() processing update audio volume group");
1156 svc = mService.promote();
1157 if (svc == 0) {
1158 break;
1159 }
1160 mLock.unlock();
1161 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
1162 mLock.lock();
1163 }break;
1164 case SET_AUDIOPORT_CONFIG: {
1165 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
1166 ALOGV("AudioCommandThread() processing set port config");
1167 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1168 if (af == 0) {
1169 command->mStatus = PERMISSION_DENIED;
1170 } else {
1171 mLock.unlock();
1172 command->mStatus = af->setAudioPortConfig(&data->mConfig);
1173 mLock.lock();
1174 }
1175 } break;
1176 case DYN_POLICY_MIX_STATE_UPDATE: {
1177 DynPolicyMixStateUpdateData *data =
1178 (DynPolicyMixStateUpdateData *)command->mParam.get();
1179 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
1180 data->mRegId.string(), data->mState);
1181 svc = mService.promote();
1182 if (svc == 0) {
1183 break;
1184 }
1185 mLock.unlock();
1186 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
1187 mLock.lock();
1188 } break;
1189 case RECORDING_CONFIGURATION_UPDATE: {
1190 RecordingConfigurationUpdateData *data =
1191 (RecordingConfigurationUpdateData *)command->mParam.get();
1192 ALOGV("AudioCommandThread() processing recording configuration update");
1193 svc = mService.promote();
1194 if (svc == 0) {
1195 break;
1196 }
1197 mLock.unlock();
1198 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
1199 &data->mClientConfig, data->mClientEffects,
1200 &data->mDeviceConfig, data->mEffects,
1201 data->mPatchHandle, data->mSource);
1202 mLock.lock();
1203 } break;
1204 case SET_EFFECT_SUSPENDED: {
1205 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
1206 ALOGV("AudioCommandThread() processing set effect suspended");
1207 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1208 if (af != 0) {
1209 mLock.unlock();
1210 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
1211 mLock.lock();
1212 }
1213 } break;
1214
1215 default:
1216 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
1217 }
1218 {
1219 Mutex::Autolock _l(command->mLock);
1220 if (command->mWaitStatus) {
1221 command->mWaitStatus = false;
1222 command->mCond.signal();
1223 }
1224 }
1225 waitTime = -1;
1226 // release mLock before releasing strong reference on the service as
1227 // AudioPolicyService destructor calls AudioCommandThread::exit() which
1228 // acquires mLock.
1229 mLock.unlock();
1230 svc.clear();
1231 mLock.lock();
1232 } else {
1233 waitTime = mAudioCommands[0]->mTime - curTime;
1234 break;
1235 }
1236 }
1237
1238 // release delayed commands wake lock if the queue is empty
1239 if (mAudioCommands.isEmpty()) {
1240 release_wake_lock(mName.string());
1241 }
1242
1243 // At this stage we have either an empty command queue or the first command in the queue
1244 // has a finite delay. So unless we are exiting it is safe to wait.
1245 if (!exitPending()) {
1246 ALOGV("AudioCommandThread() going to sleep");
1247 if (waitTime == -1) {
1248 mWaitWorkCV.wait(mLock);
1249 } else {
1250 mWaitWorkCV.waitRelative(mLock, waitTime);
1251 }
1252 }
1253 }
1254 // release delayed commands wake lock before quitting
1255 if (!mAudioCommands.isEmpty()) {
1256 release_wake_lock(mName.string());
1257 }
1258 mLock.unlock();
1259 return false;
1260 }
1261
dump(int fd)1262 status_t AudioPolicyService::AudioCommandThread::dump(int fd)
1263 {
1264 const size_t SIZE = 256;
1265 char buffer[SIZE];
1266 String8 result;
1267
1268 snprintf(buffer, SIZE, "AudioCommandThread %p Dump\n", this);
1269 result.append(buffer);
1270 write(fd, result.string(), result.size());
1271
1272 bool locked = dumpTryLock(mLock);
1273 if (!locked) {
1274 String8 result2(kCmdDeadlockedString);
1275 write(fd, result2.string(), result2.size());
1276 }
1277
1278 snprintf(buffer, SIZE, "- Commands:\n");
1279 result = String8(buffer);
1280 result.append(" Command Time Wait pParam\n");
1281 for (size_t i = 0; i < mAudioCommands.size(); i++) {
1282 mAudioCommands[i]->dump(buffer, SIZE);
1283 result.append(buffer);
1284 }
1285 result.append(" Last Command\n");
1286 if (mLastCommand != 0) {
1287 mLastCommand->dump(buffer, SIZE);
1288 result.append(buffer);
1289 } else {
1290 result.append(" none\n");
1291 }
1292
1293 write(fd, result.string(), result.size());
1294
1295 if (locked) mLock.unlock();
1296
1297 return NO_ERROR;
1298 }
1299
volumeCommand(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delayMs)1300 status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
1301 float volume,
1302 audio_io_handle_t output,
1303 int delayMs)
1304 {
1305 sp<AudioCommand> command = new AudioCommand();
1306 command->mCommand = SET_VOLUME;
1307 sp<VolumeData> data = new VolumeData();
1308 data->mStream = stream;
1309 data->mVolume = volume;
1310 data->mIO = output;
1311 command->mParam = data;
1312 command->mWaitStatus = true;
1313 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
1314 stream, volume, output);
1315 return sendCommand(command, delayMs);
1316 }
1317
parametersCommand(audio_io_handle_t ioHandle,const char * keyValuePairs,int delayMs)1318 status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
1319 const char *keyValuePairs,
1320 int delayMs)
1321 {
1322 sp<AudioCommand> command = new AudioCommand();
1323 command->mCommand = SET_PARAMETERS;
1324 sp<ParametersData> data = new ParametersData();
1325 data->mIO = ioHandle;
1326 data->mKeyValuePairs = String8(keyValuePairs);
1327 command->mParam = data;
1328 command->mWaitStatus = true;
1329 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
1330 keyValuePairs, ioHandle, delayMs);
1331 return sendCommand(command, delayMs);
1332 }
1333
voiceVolumeCommand(float volume,int delayMs)1334 status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
1335 {
1336 sp<AudioCommand> command = new AudioCommand();
1337 command->mCommand = SET_VOICE_VOLUME;
1338 sp<VoiceVolumeData> data = new VoiceVolumeData();
1339 data->mVolume = volume;
1340 command->mParam = data;
1341 command->mWaitStatus = true;
1342 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
1343 return sendCommand(command, delayMs);
1344 }
1345
setEffectSuspendedCommand(int effectId,audio_session_t sessionId,bool suspended)1346 void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
1347 audio_session_t sessionId,
1348 bool suspended)
1349 {
1350 sp<AudioCommand> command = new AudioCommand();
1351 command->mCommand = SET_EFFECT_SUSPENDED;
1352 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
1353 data->mEffectId = effectId;
1354 data->mSessionId = sessionId;
1355 data->mSuspended = suspended;
1356 command->mParam = data;
1357 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
1358 effectId, sessionId, suspended);
1359 sendCommand(command);
1360 }
1361
1362
stopOutputCommand(audio_port_handle_t portId)1363 void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
1364 {
1365 sp<AudioCommand> command = new AudioCommand();
1366 command->mCommand = STOP_OUTPUT;
1367 sp<StopOutputData> data = new StopOutputData();
1368 data->mPortId = portId;
1369 command->mParam = data;
1370 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
1371 sendCommand(command);
1372 }
1373
releaseOutputCommand(audio_port_handle_t portId)1374 void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
1375 {
1376 sp<AudioCommand> command = new AudioCommand();
1377 command->mCommand = RELEASE_OUTPUT;
1378 sp<ReleaseOutputData> data = new ReleaseOutputData();
1379 data->mPortId = portId;
1380 command->mParam = data;
1381 ALOGV("AudioCommandThread() adding release output portId %d", portId);
1382 sendCommand(command);
1383 }
1384
createAudioPatchCommand(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)1385 status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
1386 const struct audio_patch *patch,
1387 audio_patch_handle_t *handle,
1388 int delayMs)
1389 {
1390 status_t status = NO_ERROR;
1391
1392 sp<AudioCommand> command = new AudioCommand();
1393 command->mCommand = CREATE_AUDIO_PATCH;
1394 CreateAudioPatchData *data = new CreateAudioPatchData();
1395 data->mPatch = *patch;
1396 data->mHandle = *handle;
1397 command->mParam = data;
1398 command->mWaitStatus = true;
1399 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
1400 status = sendCommand(command, delayMs);
1401 if (status == NO_ERROR) {
1402 *handle = data->mHandle;
1403 }
1404 return status;
1405 }
1406
releaseAudioPatchCommand(audio_patch_handle_t handle,int delayMs)1407 status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
1408 int delayMs)
1409 {
1410 sp<AudioCommand> command = new AudioCommand();
1411 command->mCommand = RELEASE_AUDIO_PATCH;
1412 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
1413 data->mHandle = handle;
1414 command->mParam = data;
1415 command->mWaitStatus = true;
1416 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
1417 return sendCommand(command, delayMs);
1418 }
1419
updateAudioPortListCommand()1420 void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
1421 {
1422 sp<AudioCommand> command = new AudioCommand();
1423 command->mCommand = UPDATE_AUDIOPORT_LIST;
1424 ALOGV("AudioCommandThread() adding update audio port list");
1425 sendCommand(command);
1426 }
1427
updateAudioPatchListCommand()1428 void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
1429 {
1430 sp<AudioCommand>command = new AudioCommand();
1431 command->mCommand = UPDATE_AUDIOPATCH_LIST;
1432 ALOGV("AudioCommandThread() adding update audio patch list");
1433 sendCommand(command);
1434 }
1435
changeAudioVolumeGroupCommand(volume_group_t group,int flags)1436 void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
1437 int flags)
1438 {
1439 sp<AudioCommand>command = new AudioCommand();
1440 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
1441 AudioVolumeGroupData *data= new AudioVolumeGroupData();
1442 data->mGroup = group;
1443 data->mFlags = flags;
1444 command->mParam = data;
1445 ALOGV("AudioCommandThread() adding audio volume group changed");
1446 sendCommand(command);
1447 }
1448
setAudioPortConfigCommand(const struct audio_port_config * config,int delayMs)1449 status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
1450 const struct audio_port_config *config, int delayMs)
1451 {
1452 sp<AudioCommand> command = new AudioCommand();
1453 command->mCommand = SET_AUDIOPORT_CONFIG;
1454 SetAudioPortConfigData *data = new SetAudioPortConfigData();
1455 data->mConfig = *config;
1456 command->mParam = data;
1457 command->mWaitStatus = true;
1458 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
1459 return sendCommand(command, delayMs);
1460 }
1461
dynamicPolicyMixStateUpdateCommand(const String8 & regId,int32_t state)1462 void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
1463 const String8& regId, int32_t state)
1464 {
1465 sp<AudioCommand> command = new AudioCommand();
1466 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
1467 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
1468 data->mRegId = regId;
1469 data->mState = state;
1470 command->mParam = data;
1471 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
1472 regId.string(), state);
1473 sendCommand(command);
1474 }
1475
recordingConfigurationUpdateCommand(int event,const record_client_info_t * clientInfo,const audio_config_base_t * clientConfig,std::vector<effect_descriptor_t> clientEffects,const audio_config_base_t * deviceConfig,std::vector<effect_descriptor_t> effects,audio_patch_handle_t patchHandle,audio_source_t source)1476 void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
1477 int event,
1478 const record_client_info_t *clientInfo,
1479 const audio_config_base_t *clientConfig,
1480 std::vector<effect_descriptor_t> clientEffects,
1481 const audio_config_base_t *deviceConfig,
1482 std::vector<effect_descriptor_t> effects,
1483 audio_patch_handle_t patchHandle,
1484 audio_source_t source)
1485 {
1486 sp<AudioCommand>command = new AudioCommand();
1487 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
1488 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
1489 data->mEvent = event;
1490 data->mClientInfo = *clientInfo;
1491 data->mClientConfig = *clientConfig;
1492 data->mClientEffects = clientEffects;
1493 data->mDeviceConfig = *deviceConfig;
1494 data->mEffects = effects;
1495 data->mPatchHandle = patchHandle;
1496 data->mSource = source;
1497 command->mParam = data;
1498 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
1499 event, clientInfo->source, clientInfo->uid);
1500 sendCommand(command);
1501 }
1502
sendCommand(sp<AudioCommand> & command,int delayMs)1503 status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
1504 {
1505 {
1506 Mutex::Autolock _l(mLock);
1507 insertCommand_l(command, delayMs);
1508 mWaitWorkCV.signal();
1509 }
1510 Mutex::Autolock _l(command->mLock);
1511 while (command->mWaitStatus) {
1512 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
1513 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
1514 command->mStatus = TIMED_OUT;
1515 command->mWaitStatus = false;
1516 }
1517 }
1518 return command->mStatus;
1519 }
1520
1521 // insertCommand_l() must be called with mLock held
insertCommand_l(sp<AudioCommand> & command,int delayMs)1522 void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
1523 {
1524 ssize_t i; // not size_t because i will count down to -1
1525 Vector < sp<AudioCommand> > removedCommands;
1526 command->mTime = systemTime() + milliseconds(delayMs);
1527
1528 // acquire wake lock to make sure delayed commands are processed
1529 if (mAudioCommands.isEmpty()) {
1530 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
1531 }
1532
1533 // check same pending commands with later time stamps and eliminate them
1534 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
1535 sp<AudioCommand> command2 = mAudioCommands[i];
1536 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
1537 if (command2->mTime <= command->mTime) break;
1538
1539 // create audio patch or release audio patch commands are equivalent
1540 // with regard to filtering
1541 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
1542 (command->mCommand == RELEASE_AUDIO_PATCH)) {
1543 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
1544 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
1545 continue;
1546 }
1547 } else if (command2->mCommand != command->mCommand) continue;
1548
1549 switch (command->mCommand) {
1550 case SET_PARAMETERS: {
1551 ParametersData *data = (ParametersData *)command->mParam.get();
1552 ParametersData *data2 = (ParametersData *)command2->mParam.get();
1553 if (data->mIO != data2->mIO) break;
1554 ALOGV("Comparing parameter command %s to new command %s",
1555 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
1556 AudioParameter param = AudioParameter(data->mKeyValuePairs);
1557 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
1558 for (size_t j = 0; j < param.size(); j++) {
1559 String8 key;
1560 String8 value;
1561 param.getAt(j, key, value);
1562 for (size_t k = 0; k < param2.size(); k++) {
1563 String8 key2;
1564 String8 value2;
1565 param2.getAt(k, key2, value2);
1566 if (key2 == key) {
1567 param2.remove(key2);
1568 ALOGV("Filtering out parameter %s", key2.string());
1569 break;
1570 }
1571 }
1572 }
1573 // if all keys have been filtered out, remove the command.
1574 // otherwise, update the key value pairs
1575 if (param2.size() == 0) {
1576 removedCommands.add(command2);
1577 } else {
1578 data2->mKeyValuePairs = param2.toString();
1579 }
1580 command->mTime = command2->mTime;
1581 // force delayMs to non 0 so that code below does not request to wait for
1582 // command status as the command is now delayed
1583 delayMs = 1;
1584 } break;
1585
1586 case SET_VOLUME: {
1587 VolumeData *data = (VolumeData *)command->mParam.get();
1588 VolumeData *data2 = (VolumeData *)command2->mParam.get();
1589 if (data->mIO != data2->mIO) break;
1590 if (data->mStream != data2->mStream) break;
1591 ALOGV("Filtering out volume command on output %d for stream %d",
1592 data->mIO, data->mStream);
1593 removedCommands.add(command2);
1594 command->mTime = command2->mTime;
1595 // force delayMs to non 0 so that code below does not request to wait for
1596 // command status as the command is now delayed
1597 delayMs = 1;
1598 } break;
1599
1600 case SET_VOICE_VOLUME: {
1601 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
1602 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
1603 ALOGV("Filtering out voice volume command value %f replaced by %f",
1604 data2->mVolume, data->mVolume);
1605 removedCommands.add(command2);
1606 command->mTime = command2->mTime;
1607 // force delayMs to non 0 so that code below does not request to wait for
1608 // command status as the command is now delayed
1609 delayMs = 1;
1610 } break;
1611
1612 case CREATE_AUDIO_PATCH:
1613 case RELEASE_AUDIO_PATCH: {
1614 audio_patch_handle_t handle;
1615 struct audio_patch patch;
1616 if (command->mCommand == CREATE_AUDIO_PATCH) {
1617 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
1618 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
1619 } else {
1620 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
1621 memset(&patch, 0, sizeof(patch));
1622 }
1623 audio_patch_handle_t handle2;
1624 struct audio_patch patch2;
1625 if (command2->mCommand == CREATE_AUDIO_PATCH) {
1626 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
1627 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
1628 } else {
1629 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
1630 memset(&patch2, 0, sizeof(patch2));
1631 }
1632 if (handle != handle2) break;
1633 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
1634 same output. */
1635 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
1636 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
1637 bool isOutputDiff = false;
1638 if (patch.num_sources == patch2.num_sources) {
1639 for (unsigned count = 0; count < patch.num_sources; count++) {
1640 if (patch.sources[count].id != patch2.sources[count].id) {
1641 isOutputDiff = true;
1642 break;
1643 }
1644 }
1645 if (isOutputDiff)
1646 break;
1647 }
1648 }
1649 ALOGV("Filtering out %s audio patch command for handle %d",
1650 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
1651 removedCommands.add(command2);
1652 command->mTime = command2->mTime;
1653 // force delayMs to non 0 so that code below does not request to wait for
1654 // command status as the command is now delayed
1655 delayMs = 1;
1656 } break;
1657
1658 case DYN_POLICY_MIX_STATE_UPDATE: {
1659
1660 } break;
1661
1662 case RECORDING_CONFIGURATION_UPDATE: {
1663
1664 } break;
1665
1666 default:
1667 break;
1668 }
1669 }
1670
1671 // remove filtered commands
1672 for (size_t j = 0; j < removedCommands.size(); j++) {
1673 // removed commands always have time stamps greater than current command
1674 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
1675 if (mAudioCommands[k].get() == removedCommands[j].get()) {
1676 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
1677 mAudioCommands.removeAt(k);
1678 break;
1679 }
1680 }
1681 }
1682 removedCommands.clear();
1683
1684 // Disable wait for status if delay is not 0.
1685 // Except for create audio patch command because the returned patch handle
1686 // is needed by audio policy manager
1687 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
1688 command->mWaitStatus = false;
1689 }
1690
1691 // insert command at the right place according to its time stamp
1692 ALOGV("inserting command: %d at index %zd, num commands %zu",
1693 command->mCommand, i+1, mAudioCommands.size());
1694 mAudioCommands.insertAt(command, i + 1);
1695 }
1696
exit()1697 void AudioPolicyService::AudioCommandThread::exit()
1698 {
1699 ALOGV("AudioCommandThread::exit");
1700 {
1701 AutoMutex _l(mLock);
1702 requestExit();
1703 mWaitWorkCV.signal();
1704 }
1705 // Note that we can call it from the thread loop if all other references have been released
1706 // but it will safely return WOULD_BLOCK in this case
1707 requestExitAndWait();
1708 }
1709
dump(char * buffer,size_t size)1710 void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
1711 {
1712 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
1713 mCommand,
1714 (int)ns2s(mTime),
1715 (int)ns2ms(mTime)%1000,
1716 mWaitStatus,
1717 mParam.get());
1718 }
1719
1720 /******* helpers for the service_ops callbacks defined below *********/
setParameters(audio_io_handle_t ioHandle,const char * keyValuePairs,int delayMs)1721 void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
1722 const char *keyValuePairs,
1723 int delayMs)
1724 {
1725 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
1726 delayMs);
1727 }
1728
setStreamVolume(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delayMs)1729 int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
1730 float volume,
1731 audio_io_handle_t output,
1732 int delayMs)
1733 {
1734 return (int)mAudioCommandThread->volumeCommand(stream, volume,
1735 output, delayMs);
1736 }
1737
setVoiceVolume(float volume,int delayMs)1738 int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
1739 {
1740 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
1741 }
1742
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)1743 void AudioPolicyService::setEffectSuspended(int effectId,
1744 audio_session_t sessionId,
1745 bool suspended)
1746 {
1747 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
1748 }
1749
1750
1751 extern "C" {
1752 audio_module_handle_t aps_load_hw_module(void *service __unused,
1753 const char *name);
1754 audio_io_handle_t aps_open_output(void *service __unused,
1755 audio_devices_t *pDevices,
1756 uint32_t *pSamplingRate,
1757 audio_format_t *pFormat,
1758 audio_channel_mask_t *pChannelMask,
1759 uint32_t *pLatencyMs,
1760 audio_output_flags_t flags);
1761
1762 audio_io_handle_t aps_open_output_on_module(void *service __unused,
1763 audio_module_handle_t module,
1764 audio_devices_t *pDevices,
1765 uint32_t *pSamplingRate,
1766 audio_format_t *pFormat,
1767 audio_channel_mask_t *pChannelMask,
1768 uint32_t *pLatencyMs,
1769 audio_output_flags_t flags,
1770 const audio_offload_info_t *offloadInfo);
1771 audio_io_handle_t aps_open_dup_output(void *service __unused,
1772 audio_io_handle_t output1,
1773 audio_io_handle_t output2);
1774 int aps_close_output(void *service __unused, audio_io_handle_t output);
1775 int aps_suspend_output(void *service __unused, audio_io_handle_t output);
1776 int aps_restore_output(void *service __unused, audio_io_handle_t output);
1777 audio_io_handle_t aps_open_input(void *service __unused,
1778 audio_devices_t *pDevices,
1779 uint32_t *pSamplingRate,
1780 audio_format_t *pFormat,
1781 audio_channel_mask_t *pChannelMask,
1782 audio_in_acoustics_t acoustics __unused);
1783 audio_io_handle_t aps_open_input_on_module(void *service __unused,
1784 audio_module_handle_t module,
1785 audio_devices_t *pDevices,
1786 uint32_t *pSamplingRate,
1787 audio_format_t *pFormat,
1788 audio_channel_mask_t *pChannelMask);
1789 int aps_close_input(void *service __unused, audio_io_handle_t input);
1790 int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
1791 int aps_move_effects(void *service __unused, audio_session_t session,
1792 audio_io_handle_t src_output,
1793 audio_io_handle_t dst_output);
1794 char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
1795 const char *keys);
1796 void aps_set_parameters(void *service, audio_io_handle_t io_handle,
1797 const char *kv_pairs, int delay_ms);
1798 int aps_set_stream_volume(void *service, audio_stream_type_t stream,
1799 float volume, audio_io_handle_t output,
1800 int delay_ms);
1801 int aps_set_voice_volume(void *service, float volume, int delay_ms);
1802 };
1803
1804 } // namespace android
1805