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 #include <dlfcn.h>
27
28 #include <audio_utils/clock.h>
29 #include <binder/IServiceManager.h>
30 #include <utils/Log.h>
31 #include <cutils/properties.h>
32 #include <binder/IPCThreadState.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/AidlConversion.h>
40 #include <media/AudioEffect.h>
41 #include <media/AudioParameter.h>
42 #include <mediautils/MethodStatistics.h>
43 #include <mediautils/ServiceUtilities.h>
44 #include <mediautils/TimeCheck.h>
45 #include <sensorprivacy/SensorPrivacyManager.h>
46
47 #include <system/audio.h>
48 #include <system/audio_policy.h>
49 #include <AudioPolicyManager.h>
50
51 namespace android {
52 using binder::Status;
53
54 static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
55 static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
56 static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
57
58 static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
59
60 static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
61
62 static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
63
64 // Creates an association between Binder code to name for IAudioPolicyService.
65 #define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
66 BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
67 BINDER_METHOD_ENTRY(setDeviceConnectionState) \
68 BINDER_METHOD_ENTRY(getDeviceConnectionState) \
69 BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
70 BINDER_METHOD_ENTRY(setPhoneState) \
71 BINDER_METHOD_ENTRY(setForceUse) \
72 BINDER_METHOD_ENTRY(getForceUse) \
73 BINDER_METHOD_ENTRY(getOutput) \
74 BINDER_METHOD_ENTRY(getOutputForAttr) \
75 BINDER_METHOD_ENTRY(startOutput) \
76 BINDER_METHOD_ENTRY(stopOutput) \
77 BINDER_METHOD_ENTRY(releaseOutput) \
78 BINDER_METHOD_ENTRY(getInputForAttr) \
79 BINDER_METHOD_ENTRY(startInput) \
80 BINDER_METHOD_ENTRY(stopInput) \
81 BINDER_METHOD_ENTRY(releaseInput) \
82 BINDER_METHOD_ENTRY(initStreamVolume) \
83 BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
84 BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
85 BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
86 BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
87 BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
88 BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
89 BINDER_METHOD_ENTRY(getStrategyForStream) \
90 BINDER_METHOD_ENTRY(getDevicesForAttributes) \
91 BINDER_METHOD_ENTRY(getOutputForEffect) \
92 BINDER_METHOD_ENTRY(registerEffect) \
93 BINDER_METHOD_ENTRY(unregisterEffect) \
94 BINDER_METHOD_ENTRY(setEffectEnabled) \
95 BINDER_METHOD_ENTRY(moveEffectsToIo) \
96 BINDER_METHOD_ENTRY(isStreamActive) \
97 BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
98 BINDER_METHOD_ENTRY(isSourceActive) \
99 BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
100 BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
101 BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
102 BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
103 BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
104 BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
105 BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
106 BINDER_METHOD_ENTRY(getOffloadSupport) \
107 BINDER_METHOD_ENTRY(isDirectOutputSupported) \
108 BINDER_METHOD_ENTRY(listAudioPorts) \
109 BINDER_METHOD_ENTRY(getAudioPort) \
110 BINDER_METHOD_ENTRY(createAudioPatch) \
111 BINDER_METHOD_ENTRY(releaseAudioPatch) \
112 BINDER_METHOD_ENTRY(listAudioPatches) \
113 BINDER_METHOD_ENTRY(setAudioPortConfig) \
114 BINDER_METHOD_ENTRY(registerClient) \
115 BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
116 BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
117 BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
118 BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
119 BINDER_METHOD_ENTRY(getPhoneState) \
120 BINDER_METHOD_ENTRY(registerPolicyMixes) \
121 BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
122 BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
123 BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
124 BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
125 BINDER_METHOD_ENTRY(startAudioSource) \
126 BINDER_METHOD_ENTRY(stopAudioSource) \
127 BINDER_METHOD_ENTRY(setMasterMono) \
128 BINDER_METHOD_ENTRY(getMasterMono) \
129 BINDER_METHOD_ENTRY(getStreamVolumeDB) \
130 BINDER_METHOD_ENTRY(getSurroundFormats) \
131 BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
132 BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
133 BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
134 BINDER_METHOD_ENTRY(setAssistantServicesUids) \
135 BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
136 BINDER_METHOD_ENTRY(setA11yServicesUids) \
137 BINDER_METHOD_ENTRY(setCurrentImeUid) \
138 BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
139 BINDER_METHOD_ENTRY(isUltrasoundSupported) \
140 BINDER_METHOD_ENTRY(listAudioProductStrategies) \
141 BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
142 BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
143 BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
144 BINDER_METHOD_ENTRY(setRttEnabled) \
145 BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
146 BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
147 BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
148 BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
149 BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
150 BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
151 BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
152 BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
153 BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
154 BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
155 BINDER_METHOD_ENTRY(getSpatializer) \
156 BINDER_METHOD_ENTRY(canBeSpatialized) \
157 BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
158 BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
159
160 // singleton for Binder Method Statistics for IAudioPolicyService
getIAudioPolicyServiceStatistics()161 static auto& getIAudioPolicyServiceStatistics() {
162 using Code = int;
163
164 #pragma push_macro("BINDER_METHOD_ENTRY")
165 #undef BINDER_METHOD_ENTRY
166 #define BINDER_METHOD_ENTRY(ENTRY) \
167 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
168
169 static mediautils::MethodStatistics<Code> methodStatistics{
170 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
171 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
172 };
173 #pragma pop_macro("BINDER_METHOD_ENTRY")
174
175 return methodStatistics;
176 }
177
178 // ----------------------------------------------------------------------------
179
createAudioPolicyManager(AudioPolicyClientInterface * clientInterface)180 static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
181 {
182 AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);
183 status_t status = apm->initialize();
184 if (status != NO_ERROR) {
185 delete apm;
186 apm = nullptr;
187 }
188 return apm;
189 }
190
destroyAudioPolicyManager(AudioPolicyInterface * interface)191 static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
192 {
193 delete interface;
194 }
195 // ----------------------------------------------------------------------------
196
AudioPolicyService()197 AudioPolicyService::AudioPolicyService()
198 : BnAudioPolicyService(),
199 mAudioPolicyManager(NULL),
200 mAudioPolicyClient(NULL),
201 mPhoneState(AUDIO_MODE_INVALID),
202 mCaptureStateNotifier(false),
203 mCreateAudioPolicyManager(createAudioPolicyManager),
204 mDestroyAudioPolicyManager(destroyAudioPolicyManager) {
205 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
206 }
207
loadAudioPolicyManager()208 void AudioPolicyService::loadAudioPolicyManager()
209 {
210 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
211 if (mLibraryHandle != nullptr) {
212 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
213 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
214 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
215 const char *lastError = dlerror();
216 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
217 __func__, lastError != nullptr ? lastError : "no error");
218
219 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
220 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
221 lastError = dlerror();
222 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
223 __func__, lastError != nullptr ? lastError : "no error");
224 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
225 unloadAudioPolicyManager();
226 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
227 }
228 }
229 }
230
onFirstRef()231 void AudioPolicyService::onFirstRef()
232 {
233 // Log an AudioPolicy "constructor" mediametrics event on first ref.
234 // This records the time it takes to load the audio modules and devices.
235 mediametrics::Defer defer([beginNs = systemTime()] {
236 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
237 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
238 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
239 .record(); });
240 {
241 Mutex::Autolock _l(mLock);
242
243 // start audio commands thread
244 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
245 // start output activity command thread
246 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
247
248 mAudioPolicyClient = new AudioPolicyClient(this);
249
250 loadAudioPolicyManager();
251 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
252 }
253
254 // load audio processing modules
255 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
256 sp<UidPolicy> uidPolicy = new UidPolicy(this);
257 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
258 {
259 Mutex::Autolock _l(mLock);
260 mAudioPolicyEffects = audioPolicyEffects;
261 mUidPolicy = uidPolicy;
262 mSensorPrivacyPolicy = sensorPrivacyPolicy;
263 }
264 uidPolicy->registerSelf();
265 sensorPrivacyPolicy->registerSelf();
266
267 // Create spatializer if supported
268 if (mAudioPolicyManager != nullptr) {
269 Mutex::Autolock _l(mLock);
270 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
271 AudioDeviceTypeAddrVector devices;
272 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
273 if (hasSpatializer) {
274 mSpatializer = Spatializer::create(this);
275 }
276 if (mSpatializer == nullptr) {
277 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
278 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
279 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
280 }
281 }
282 AudioSystem::audioPolicyReady();
283 }
284
unloadAudioPolicyManager()285 void AudioPolicyService::unloadAudioPolicyManager()
286 {
287 ALOGV("%s ", __func__);
288 if (mLibraryHandle != nullptr) {
289 dlclose(mLibraryHandle);
290 }
291 mLibraryHandle = nullptr;
292 mCreateAudioPolicyManager = nullptr;
293 mDestroyAudioPolicyManager = nullptr;
294 }
295
~AudioPolicyService()296 AudioPolicyService::~AudioPolicyService()
297 {
298 mAudioCommandThread->exit();
299 mOutputCommandThread->exit();
300
301 mDestroyAudioPolicyManager(mAudioPolicyManager);
302 unloadAudioPolicyManager();
303
304 delete mAudioPolicyClient;
305
306 mNotificationClients.clear();
307 mAudioPolicyEffects.clear();
308
309 mUidPolicy->unregisterSelf();
310 mSensorPrivacyPolicy->unregisterSelf();
311
312 mUidPolicy.clear();
313 mSensorPrivacyPolicy.clear();
314 }
315
316 // A notification client is always registered by AudioSystem when the client process
317 // connects to AudioPolicyService.
registerClient(const sp<media::IAudioPolicyServiceClient> & client)318 Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
319 {
320 if (client == 0) {
321 ALOGW("%s got NULL client", __FUNCTION__);
322 return Status::ok();
323 }
324 Mutex::Autolock _l(mNotificationClientsLock);
325
326 uid_t uid = IPCThreadState::self()->getCallingUid();
327 pid_t pid = IPCThreadState::self()->getCallingPid();
328 int64_t token = ((int64_t)uid<<32) | pid;
329
330 if (mNotificationClients.indexOfKey(token) < 0) {
331 sp<NotificationClient> notificationClient = new NotificationClient(this,
332 client,
333 uid,
334 pid);
335 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
336
337 mNotificationClients.add(token, notificationClient);
338
339 sp<IBinder> binder = IInterface::asBinder(client);
340 binder->linkToDeath(notificationClient);
341 }
342 return Status::ok();
343 }
344
setAudioPortCallbacksEnabled(bool enabled)345 Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
346 {
347 Mutex::Autolock _l(mNotificationClientsLock);
348
349 uid_t uid = IPCThreadState::self()->getCallingUid();
350 pid_t pid = IPCThreadState::self()->getCallingPid();
351 int64_t token = ((int64_t)uid<<32) | pid;
352
353 if (mNotificationClients.indexOfKey(token) < 0) {
354 return Status::ok();
355 }
356 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
357 return Status::ok();
358 }
359
setAudioVolumeGroupCallbacksEnabled(bool enabled)360 Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
361 {
362 Mutex::Autolock _l(mNotificationClientsLock);
363
364 uid_t uid = IPCThreadState::self()->getCallingUid();
365 pid_t pid = IPCThreadState::self()->getCallingPid();
366 int64_t token = ((int64_t)uid<<32) | pid;
367
368 if (mNotificationClients.indexOfKey(token) < 0) {
369 return Status::ok();
370 }
371 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
372 return Status::ok();
373 }
374
375 // removeNotificationClient() is called when the client process dies.
removeNotificationClient(uid_t uid,pid_t pid)376 void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
377 {
378 bool hasSameUid = false;
379 {
380 Mutex::Autolock _l(mNotificationClientsLock);
381 int64_t token = ((int64_t)uid<<32) | pid;
382 mNotificationClients.removeItem(token);
383 for (size_t i = 0; i < mNotificationClients.size(); i++) {
384 if (mNotificationClients.valueAt(i)->uid() == uid) {
385 hasSameUid = true;
386 break;
387 }
388 }
389 }
390 {
391 Mutex::Autolock _l(mLock);
392 if (mAudioPolicyManager && !hasSameUid) {
393 // called from binder death notification: no need to clear caller identity
394 mAudioPolicyManager->releaseResourcesForUid(uid);
395 }
396 }
397 }
398
onAudioPortListUpdate()399 void AudioPolicyService::onAudioPortListUpdate()
400 {
401 mOutputCommandThread->updateAudioPortListCommand();
402 }
403
doOnAudioPortListUpdate()404 void AudioPolicyService::doOnAudioPortListUpdate()
405 {
406 Mutex::Autolock _l(mNotificationClientsLock);
407 for (size_t i = 0; i < mNotificationClients.size(); i++) {
408 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
409 }
410 }
411
onAudioPatchListUpdate()412 void AudioPolicyService::onAudioPatchListUpdate()
413 {
414 mOutputCommandThread->updateAudioPatchListCommand();
415 }
416
doOnAudioPatchListUpdate()417 void AudioPolicyService::doOnAudioPatchListUpdate()
418 {
419 Mutex::Autolock _l(mNotificationClientsLock);
420 for (size_t i = 0; i < mNotificationClients.size(); i++) {
421 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
422 }
423 }
424
onAudioVolumeGroupChanged(volume_group_t group,int flags)425 void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
426 {
427 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
428 }
429
doOnAudioVolumeGroupChanged(volume_group_t group,int flags)430 void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
431 {
432 Mutex::Autolock _l(mNotificationClientsLock);
433 for (size_t i = 0; i < mNotificationClients.size(); i++) {
434 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
435 }
436 }
437
onDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)438 void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
439 {
440 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
441 regId.string(), state);
442 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
443 }
444
doOnDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)445 void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
446 {
447 Mutex::Autolock _l(mNotificationClientsLock);
448 for (size_t i = 0; i < mNotificationClients.size(); i++) {
449 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
450 }
451 }
452
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)453 void AudioPolicyService::onRecordingConfigurationUpdate(
454 int event,
455 const record_client_info_t *clientInfo,
456 const audio_config_base_t *clientConfig,
457 std::vector<effect_descriptor_t> clientEffects,
458 const audio_config_base_t *deviceConfig,
459 std::vector<effect_descriptor_t> effects,
460 audio_patch_handle_t patchHandle,
461 audio_source_t source)
462 {
463 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
464 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
465 }
466
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)467 void AudioPolicyService::doOnRecordingConfigurationUpdate(
468 int event,
469 const record_client_info_t *clientInfo,
470 const audio_config_base_t *clientConfig,
471 std::vector<effect_descriptor_t> clientEffects,
472 const audio_config_base_t *deviceConfig,
473 std::vector<effect_descriptor_t> effects,
474 audio_patch_handle_t patchHandle,
475 audio_source_t source)
476 {
477 Mutex::Autolock _l(mNotificationClientsLock);
478 for (size_t i = 0; i < mNotificationClients.size(); i++) {
479 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
480 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
481 }
482 }
483
onRoutingUpdated()484 void AudioPolicyService::onRoutingUpdated()
485 {
486 mOutputCommandThread->routingChangedCommand();
487 }
488
doOnRoutingUpdated()489 void AudioPolicyService::doOnRoutingUpdated()
490 {
491 Mutex::Autolock _l(mNotificationClientsLock);
492 for (size_t i = 0; i < mNotificationClients.size(); i++) {
493 mNotificationClients.valueAt(i)->onRoutingUpdated();
494 }
495 }
496
onVolumeRangeInitRequest()497 void AudioPolicyService::onVolumeRangeInitRequest()
498 {
499 mOutputCommandThread->volRangeInitReqCommand();
500 }
501
doOnVolumeRangeInitRequest()502 void AudioPolicyService::doOnVolumeRangeInitRequest()
503 {
504 Mutex::Autolock _l(mNotificationClientsLock);
505 for (size_t i = 0; i < mNotificationClients.size(); i++) {
506 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
507 }
508 }
509
onCheckSpatializer()510 void AudioPolicyService::onCheckSpatializer()
511 {
512 Mutex::Autolock _l(mLock);
513 onCheckSpatializer_l();
514 }
515
onCheckSpatializer_l()516 void AudioPolicyService::onCheckSpatializer_l()
517 {
518 if (mSpatializer != nullptr) {
519 mOutputCommandThread->checkSpatializerCommand();
520 }
521 }
522
doOnCheckSpatializer()523 void AudioPolicyService::doOnCheckSpatializer()
524 {
525 ALOGV("%s mSpatializer %p level %d",
526 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
527
528 if (mSpatializer != nullptr) {
529 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
530 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
531 audio_io_handle_t currentOutput = mSpatializer->getOutput();
532 audio_io_handle_t newOutput;
533 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
534 audio_config_base_t config = mSpatializer->getAudioInConfig();
535
536 Mutex::Autolock _l(mLock);
537 status_t status =
538 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
539 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
540 __func__, currentOutput, newOutput, config.channel_mask);
541 if (status == NO_ERROR && currentOutput == newOutput) {
542 return;
543 }
544 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
545 mLock.unlock();
546 // It is OK to call detachOutput() is none is already attached.
547 mSpatializer->detachOutput();
548 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
549 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
550 }
551 mLock.lock();
552 if (status != NO_ERROR) {
553 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
554 }
555 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
556 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
557 audio_io_handle_t output = mSpatializer->detachOutput();
558
559 if (output != AUDIO_IO_HANDLE_NONE) {
560 Mutex::Autolock _l(mLock);
561 mAudioPolicyManager->releaseSpatializerOutput(output);
562 }
563 }
564 }
565 }
566
countActiveClientsOnOutput_l(audio_io_handle_t output,bool spatializedOnly)567 size_t AudioPolicyService::countActiveClientsOnOutput_l(
568 audio_io_handle_t output, bool spatializedOnly) {
569 size_t count = 0;
570 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
571 auto client = mAudioPlaybackClients.valueAt(i);
572 if (client->io == output && client->active
573 && (!spatializedOnly || client->isSpatialized)) {
574 count++;
575 }
576 }
577 return count;
578 }
579
onUpdateActiveSpatializerTracks_l()580 void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
581 if (mSpatializer == nullptr) {
582 return;
583 }
584 mOutputCommandThread->updateActiveSpatializerTracksCommand();
585 }
586
doOnUpdateActiveSpatializerTracks()587 void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
588 {
589 if (mSpatializer == nullptr) {
590 return;
591 }
592 audio_io_handle_t output = mSpatializer->getOutput();
593 size_t activeClients;
594 {
595 Mutex::Autolock _l(mLock);
596 activeClients = countActiveClientsOnOutput_l(output);
597 }
598 mSpatializer->updateActiveTracks(activeClients);
599 }
600
clientCreateAudioPatch(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)601 status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
602 audio_patch_handle_t *handle,
603 int delayMs)
604 {
605 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
606 }
607
clientReleaseAudioPatch(audio_patch_handle_t handle,int delayMs)608 status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
609 int delayMs)
610 {
611 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
612 }
613
clientSetAudioPortConfig(const struct audio_port_config * config,int delayMs)614 status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
615 int delayMs)
616 {
617 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
618 }
619
NotificationClient(const sp<AudioPolicyService> & service,const sp<media::IAudioPolicyServiceClient> & client,uid_t uid,pid_t pid)620 AudioPolicyService::NotificationClient::NotificationClient(
621 const sp<AudioPolicyService>& service,
622 const sp<media::IAudioPolicyServiceClient>& client,
623 uid_t uid,
624 pid_t pid)
625 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
626 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
627 {
628 }
629
~NotificationClient()630 AudioPolicyService::NotificationClient::~NotificationClient()
631 {
632 }
633
binderDied(const wp<IBinder> & who __unused)634 void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
635 {
636 sp<NotificationClient> keep(this);
637 sp<AudioPolicyService> service = mService.promote();
638 if (service != 0) {
639 service->removeNotificationClient(mUid, mPid);
640 }
641 }
642
onAudioPortListUpdate()643 void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
644 {
645 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
646 mAudioPolicyServiceClient->onAudioPortListUpdate();
647 }
648 }
649
onAudioPatchListUpdate()650 void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
651 {
652 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
653 mAudioPolicyServiceClient->onAudioPatchListUpdate();
654 }
655 }
656
onAudioVolumeGroupChanged(volume_group_t group,int flags)657 void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
658 int flags)
659 {
660 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
661 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
662 }
663 }
664
665
onDynamicPolicyMixStateUpdate(const String8 & regId,int32_t state)666 void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
667 const String8& regId, int32_t state)
668 {
669 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
670 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
671 legacy2aidl_String8_string(regId).value(), state);
672 }
673 }
674
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)675 void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
676 int event,
677 const record_client_info_t *clientInfo,
678 const audio_config_base_t *clientConfig,
679 std::vector<effect_descriptor_t> clientEffects,
680 const audio_config_base_t *deviceConfig,
681 std::vector<effect_descriptor_t> effects,
682 audio_patch_handle_t patchHandle,
683 audio_source_t source)
684 {
685 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
686 status_t status = [&]() -> status_t {
687 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
688 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
689 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
690 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
691 legacy2aidl_audio_config_base_t_AudioConfigBase(
692 *clientConfig, true /*isInput*/));
693 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
694 convertContainer<std::vector<media::EffectDescriptor>>(
695 clientEffects,
696 legacy2aidl_effect_descriptor_t_EffectDescriptor));
697 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
698 legacy2aidl_audio_config_base_t_AudioConfigBase(
699 *deviceConfig, true /*isInput*/));
700 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
701 convertContainer<std::vector<media::EffectDescriptor>>(
702 effects,
703 legacy2aidl_effect_descriptor_t_EffectDescriptor));
704 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
705 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
706 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
707 legacy2aidl_audio_source_t_AudioSource(source));
708 return aidl_utils::statusTFromBinderStatus(
709 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
710 clientInfoAidl,
711 clientConfigAidl,
712 clientEffectsAidl,
713 deviceConfigAidl,
714 effectsAidl,
715 patchHandleAidl,
716 sourceAidl));
717 }();
718 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
719 }
720 }
721
setAudioPortCallbacksEnabled(bool enabled)722 void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
723 {
724 mAudioPortCallbacksEnabled = enabled;
725 }
726
setAudioVolumeGroupCallbacksEnabled(bool enabled)727 void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
728 {
729 mAudioVolumeGroupCallbacksEnabled = enabled;
730 }
731
onRoutingUpdated()732 void AudioPolicyService::NotificationClient::onRoutingUpdated()
733 {
734 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
735 mAudioPolicyServiceClient->onRoutingUpdated();
736 }
737 }
738
onVolumeRangeInitRequest()739 void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
740 {
741 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
742 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
743 }
744 }
745
binderDied(const wp<IBinder> & who)746 void AudioPolicyService::binderDied(const wp<IBinder>& who) {
747 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
748 IPCThreadState::self()->getCallingPid());
749 }
750
dumpTryLock(Mutex & mutex)751 static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
752 {
753 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
754 }
755
dumpReleaseLock(Mutex & mutex,bool locked)756 static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
757 {
758 if (locked) mutex.unlock();
759 }
760
dumpInternals(int fd)761 status_t AudioPolicyService::dumpInternals(int fd)
762 {
763 const size_t SIZE = 256;
764 char buffer[SIZE];
765 String8 result;
766
767 snprintf(buffer, SIZE, "Supported System Usages:\n ");
768 result.append(buffer);
769 std::stringstream msg;
770 size_t i = 0;
771 for (auto usage : mSupportedSystemUsages) {
772 if (i++ != 0) msg << ", ";
773 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
774 msg << strUsage;
775 } else {
776 msg << usage << " (unknown)";
777 }
778 }
779 if (i == 0) {
780 msg << "None";
781 }
782 msg << std::endl;
783 result.append(msg.str().c_str());
784
785 write(fd, result.string(), result.size());
786
787 mUidPolicy->dumpInternals(fd);
788 return NO_ERROR;
789 }
790
updateUidStates()791 void AudioPolicyService::updateUidStates()
792 {
793 Mutex::Autolock _l(mLock);
794 updateUidStates_l();
795 }
796
updateUidStates_l()797 void AudioPolicyService::updateUidStates_l()
798 {
799 // Go over all active clients and allow capture (does not force silence) in the
800 // following cases:
801 // The client is in the active assistant list
802 // AND is TOP
803 // AND an accessibility service is TOP
804 // AND source is either VOICE_RECOGNITION OR HOTWORD
805 // OR there is no active privacy sensitive capture or call
806 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
807 // AND source is VOICE_RECOGNITION OR HOTWORD
808 // The client is an assistant AND active assistant is not being used
809 // AND an accessibility service is on TOP or a RTT call is active
810 // AND the source is VOICE_RECOGNITION or HOTWORD
811 // OR there is no active privacy sensitive capture or call
812 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
813 // AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
814 // OR there is no top recent assistant and source is HOTWORD
815 // OR The client is an accessibility service
816 // AND Is on TOP
817 // AND the source is VOICE_RECOGNITION or HOTWORD
818 // OR The assistant is not on TOP
819 // AND there is no active privacy sensitive capture or call
820 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
821 // AND is on TOP
822 // AND the source is VOICE_RECOGNITION or HOTWORD
823 // OR the client source is virtual (remote submix, call audio TX or RX...)
824 // OR the client source is HOTWORD
825 // AND is on TOP
826 // OR all active clients are using HOTWORD source
827 // AND no call is active
828 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
829 // OR the client is the current InputMethodService
830 // AND a RTT call is active AND the source is VOICE_RECOGNITION
831 // OR Any client
832 // AND The assistant is not on TOP
833 // AND is on TOP or latest started
834 // AND there is no active privacy sensitive capture or call
835 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
836
837
838 sp<AudioRecordClient> topActive;
839 sp<AudioRecordClient> latestActive;
840 sp<AudioRecordClient> topSensitiveActive;
841 sp<AudioRecordClient> latestSensitiveActiveOrComm;
842 sp<AudioRecordClient> latestActiveAssistant;
843
844 nsecs_t topStartNs = 0;
845 nsecs_t latestStartNs = 0;
846 nsecs_t topSensitiveStartNs = 0;
847 nsecs_t latestSensitiveStartNs = 0;
848 nsecs_t latestAssistantStartNs = 0;
849 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
850 bool isAssistantOnTop = false;
851 bool useActiveAssistantList = false;
852 bool isSensitiveActive = false;
853 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
854 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
855 bool rttCallActive = (isInCall || isInCommunication)
856 && mUidPolicy->isRttEnabled();
857 bool onlyHotwordActive = true;
858 bool isPhoneStateOwnerActive = false;
859
860 // if Sensor Privacy is enabled then all recordings should be silenced.
861 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
862 silenceAllRecordings_l();
863 return;
864 }
865
866 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
867 sp<AudioRecordClient> current = mAudioRecordClients[i];
868 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
869 current->attributionSource.uid));
870 if (!current->active) {
871 continue;
872 }
873
874 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
875 // clients which app is in IDLE state are not eligible for top active or
876 // latest active
877 if (appState == APP_STATE_IDLE) {
878 continue;
879 }
880
881 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
882 // Clients capturing for Accessibility services or virtual sources are not considered
883 // for top or latest active to avoid masking regular clients started before
884 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
885 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
886 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
887 bool isPrivacySensitive =
888 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
889
890 if (appState == APP_STATE_TOP) {
891 if (isPrivacySensitive) {
892 if (current->startTimeNs > topSensitiveStartNs) {
893 topSensitiveActive = current;
894 topSensitiveStartNs = current->startTimeNs;
895 }
896 } else {
897 if (current->startTimeNs > topStartNs) {
898 topActive = current;
899 topStartNs = current->startTimeNs;
900 }
901 }
902 if (isAssistant) {
903 isAssistantOnTop = true;
904 if (isActiveAssistant) {
905 useActiveAssistantList = true;
906 } else if (!useActiveAssistantList) {
907 if (current->startTimeNs > latestAssistantStartNs) {
908 latestActiveAssistant = current;
909 latestAssistantStartNs = current->startTimeNs;
910 }
911 }
912 }
913 }
914 // Clients capturing for HOTWORD are not considered
915 // for latest active to avoid masking regular clients started before
916 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
917 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
918 if (isPrivacySensitive) {
919 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
920 // is marked latest sensitive active even if another app qualifies.
921 if (current->startTimeNs > latestSensitiveStartNs
922 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
923 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
924 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
925 latestSensitiveActiveOrComm->attributionSource.uid))
926 != mPhoneStateOwnerUid) {
927 latestSensitiveActiveOrComm = current;
928 latestSensitiveStartNs = current->startTimeNs;
929 }
930 }
931 isSensitiveActive = true;
932 } else {
933 if (current->startTimeNs > latestStartNs) {
934 latestActive = current;
935 latestStartNs = current->startTimeNs;
936 }
937 }
938 }
939 }
940 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
941 onlyHotwordActive = false;
942 }
943 if (currentUid == mPhoneStateOwnerUid &&
944 !isVirtualSource(current->attributes.source)) {
945 isPhoneStateOwnerActive = true;
946 }
947 }
948
949 // if no active client with UI on Top, consider latest active as top
950 if (topActive == nullptr) {
951 topActive = latestActive;
952 topStartNs = latestStartNs;
953 }
954 if (topSensitiveActive == nullptr) {
955 topSensitiveActive = latestSensitiveActiveOrComm;
956 topSensitiveStartNs = latestSensitiveStartNs;
957 } else if (latestSensitiveActiveOrComm != nullptr) {
958 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
959 // foreground UI in case both are capturing with privacy sensitive flag.
960 uid_t latestActiveUid = VALUE_OR_FATAL(
961 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
962 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
963 topSensitiveActive = latestSensitiveActiveOrComm;
964 topSensitiveStartNs = latestSensitiveStartNs;
965 }
966 }
967
968 // If both privacy sensitive and regular capture are active:
969 // if the regular capture is privileged
970 // allow concurrency
971 // else
972 // favor the privacy sensitive case
973 if (topActive != nullptr && topSensitiveActive != nullptr
974 && !topActive->canCaptureOutput) {
975 topActive = nullptr;
976 }
977
978 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
979 sp<AudioRecordClient> current = mAudioRecordClients[i];
980 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
981 current->attributionSource.uid));
982 if (!current->active) {
983 continue;
984 }
985
986 audio_source_t source = current->attributes.source;
987 bool isTopOrLatestActive = topActive == nullptr ? false :
988 current->attributionSource.uid == topActive->attributionSource.uid;
989 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
990 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
991 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
992 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
993
994 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
995 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
996 recordClient->attributionSource.uid));
997 bool canCaptureCall = recordClient->canCaptureOutput;
998 bool canCaptureCommunication = recordClient->canCaptureOutput
999 || !isPhoneStateOwnerActive
1000 || recordUid == mPhoneStateOwnerUid;
1001 return !(isInCall && !canCaptureCall)
1002 && !(isInCommunication && !canCaptureCommunication);
1003 };
1004
1005 // By default allow capture if:
1006 // The assistant is not on TOP
1007 // AND is on TOP or latest started
1008 // AND there is no active privacy sensitive capture or call
1009 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1010 bool allowCapture = !isAssistantOnTop
1011 && (isTopOrLatestActive || isTopOrLatestSensitive)
1012 && !(isSensitiveActive
1013 && !(isTopOrLatestSensitive || current->canCaptureOutput))
1014 && canCaptureIfInCallOrCommunication(current);
1015
1016 if (!current->hasOp()) {
1017 // Never allow capture if app op is denied
1018 allowCapture = false;
1019 } else if (isVirtualSource(source)) {
1020 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1021 allowCapture = true;
1022 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
1023 // For assistant allow capture if:
1024 // Active assistant list is not being used
1025 // AND accessibility service is on TOP or a RTT call is active
1026 // AND the source is VOICE_RECOGNITION or HOTWORD
1027 // OR there is no active privacy sensitive capture or call
1028 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1029 // AND is latest TOP assistant AND
1030 // uses VOICE_RECOGNITION OR uses HOTWORD
1031 // OR there is no TOP assistant and uses HOTWORD
1032 if (isA11yOnTop || rttCallActive) {
1033 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1034 allowCapture = true;
1035 }
1036 } else if (!(isSensitiveActive && !current->canCaptureOutput)
1037 && canCaptureIfInCallOrCommunication(current)) {
1038 if (isTopOrLatestAssistant
1039 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1040 || source == AUDIO_SOURCE_HOTWORD)) {
1041 allowCapture = true;
1042 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1043 allowCapture = true;
1044 }
1045 }
1046 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1047 // For assistant on active list and on top allow capture if:
1048 // An accessibility service is on TOP
1049 // AND the source is VOICE_RECOGNITION or HOTWORD
1050 // OR there is no active privacy sensitive capture or call
1051 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1052 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1053 if (isA11yOnTop) {
1054 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1055 allowCapture = true;
1056 }
1057 } else if (!(isSensitiveActive && !current->canCaptureOutput)
1058 && canCaptureIfInCallOrCommunication(current)) {
1059 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1060 {
1061 allowCapture = true;
1062 }
1063 }
1064 } else if (mUidPolicy->isA11yUid(currentUid)) {
1065 // For accessibility service allow capture if:
1066 // The assistant is not on TOP
1067 // AND there is no active privacy sensitive capture or call
1068 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1069 // OR
1070 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1071 if (!isAssistantOnTop
1072 && !(isSensitiveActive && !current->canCaptureOutput)
1073 && canCaptureIfInCallOrCommunication(current)) {
1074 allowCapture = true;
1075 }
1076 if (isA11yOnTop) {
1077 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1078 allowCapture = true;
1079 }
1080 }
1081 } else if (source == AUDIO_SOURCE_HOTWORD) {
1082 // For HOTWORD source allow capture when not on TOP if:
1083 // All active clients are using HOTWORD source
1084 // AND no call is active
1085 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1086 if (onlyHotwordActive
1087 && canCaptureIfInCallOrCommunication(current)) {
1088 allowCapture = true;
1089 }
1090 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
1091 // For current InputMethodService allow capture if:
1092 // A RTT call is active AND the source is VOICE_RECOGNITION
1093 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1094 allowCapture = true;
1095 }
1096 }
1097 setAppState_l(current,
1098 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
1099 APP_STATE_IDLE);
1100 }
1101 }
1102
silenceAllRecordings_l()1103 void AudioPolicyService::silenceAllRecordings_l() {
1104 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1105 sp<AudioRecordClient> current = mAudioRecordClients[i];
1106 if (!isVirtualSource(current->attributes.source)) {
1107 setAppState_l(current, APP_STATE_IDLE);
1108 }
1109 }
1110 }
1111
1112 /* static */
apmStatFromAmState(int amState)1113 app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
1114
1115 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
1116 return APP_STATE_IDLE;
1117 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1118 // include persistent services
1119 return APP_STATE_TOP;
1120 }
1121 return APP_STATE_FOREGROUND;
1122 }
1123
1124 /* static */
isVirtualSource(audio_source_t source)1125 bool AudioPolicyService::isVirtualSource(audio_source_t source)
1126 {
1127 switch (source) {
1128 case AUDIO_SOURCE_VOICE_UPLINK:
1129 case AUDIO_SOURCE_VOICE_DOWNLINK:
1130 case AUDIO_SOURCE_VOICE_CALL:
1131 case AUDIO_SOURCE_REMOTE_SUBMIX:
1132 case AUDIO_SOURCE_FM_TUNER:
1133 case AUDIO_SOURCE_ECHO_REFERENCE:
1134 return true;
1135 default:
1136 break;
1137 }
1138 return false;
1139 }
1140
1141 /* static */
isAppOpSource(audio_source_t source)1142 bool AudioPolicyService::isAppOpSource(audio_source_t source)
1143 {
1144 switch (source) {
1145 case AUDIO_SOURCE_FM_TUNER:
1146 case AUDIO_SOURCE_ECHO_REFERENCE:
1147 case AUDIO_SOURCE_REMOTE_SUBMIX:
1148 return false;
1149 default:
1150 break;
1151 }
1152 return true;
1153 }
1154
setAppState_l(sp<AudioRecordClient> client,app_state_t state)1155 void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
1156 {
1157 AutoCallerClear acc;
1158
1159 if (mAudioPolicyManager) {
1160 mAudioPolicyManager->setAppState(client->portId, state);
1161 }
1162 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1163 if (af) {
1164 bool silenced = state == APP_STATE_IDLE;
1165 if (client->silenced != silenced) {
1166 if (client->active) {
1167 if (silenced) {
1168 finishRecording(client->attributionSource, client->attributes.source);
1169 } else {
1170 std::stringstream msg;
1171 msg << "Audio recording un-silenced on session " << client->session;
1172 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1173 client->attributes.source)) {
1174 silenced = true;
1175 }
1176 }
1177 }
1178 af->setRecordSilenced(client->portId, silenced);
1179 client->silenced = silenced;
1180 }
1181 }
1182 }
1183
dump(int fd,const Vector<String16> & args __unused)1184 status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
1185 {
1186 if (!dumpAllowed()) {
1187 dumpPermissionDenial(fd);
1188 } else {
1189 const bool locked = dumpTryLock(mLock);
1190 if (!locked) {
1191 String8 result(kDeadlockedString);
1192 write(fd, result.string(), result.size());
1193 }
1194
1195 dumpInternals(fd);
1196
1197 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1198 write(fd, actPtr.string(), actPtr.size());
1199 if (mAudioCommandThread != 0) {
1200 mAudioCommandThread->dump(fd);
1201 }
1202
1203 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1204 write(fd, octPtr.string(), octPtr.size());
1205 if (mOutputCommandThread != 0) {
1206 mOutputCommandThread->dump(fd);
1207 }
1208
1209 if (mAudioPolicyManager) {
1210 mAudioPolicyManager->dump(fd);
1211 } else {
1212 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1213 write(fd, apmPtr.string(), apmPtr.size());
1214 }
1215
1216 mPackageManager.dump(fd);
1217
1218 dumpReleaseLock(mLock, locked);
1219
1220 if (mSpatializer != nullptr) {
1221 std::string dumpString = mSpatializer->toString(1 /* level */);
1222 write(fd, dumpString.c_str(), dumpString.size());
1223 } else {
1224 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1225 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1226 }
1227
1228 {
1229 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1230 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1231 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1232 }
1233 }
1234 return NO_ERROR;
1235 }
1236
dumpPermissionDenial(int fd)1237 status_t AudioPolicyService::dumpPermissionDenial(int fd)
1238 {
1239 const size_t SIZE = 256;
1240 char buffer[SIZE];
1241 String8 result;
1242 snprintf(buffer, SIZE, "Permission Denial: "
1243 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1244 IPCThreadState::self()->getCallingPid(),
1245 IPCThreadState::self()->getCallingUid());
1246 result.append(buffer);
1247 write(fd, result.string(), result.size());
1248 return NO_ERROR;
1249 }
1250
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)1251 status_t AudioPolicyService::onTransact(
1252 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
1253 // make sure transactions reserved to AudioFlinger do not come from other processes
1254 switch (code) {
1255 case TRANSACTION_startOutput:
1256 case TRANSACTION_stopOutput:
1257 case TRANSACTION_releaseOutput:
1258 case TRANSACTION_getInputForAttr:
1259 case TRANSACTION_startInput:
1260 case TRANSACTION_stopInput:
1261 case TRANSACTION_releaseInput:
1262 case TRANSACTION_getOutputForEffect:
1263 case TRANSACTION_registerEffect:
1264 case TRANSACTION_unregisterEffect:
1265 case TRANSACTION_setEffectEnabled:
1266 case TRANSACTION_getStrategyForStream:
1267 case TRANSACTION_getOutputForAttr:
1268 case TRANSACTION_moveEffectsToIo:
1269 ALOGW("%s: transaction %d received from PID %d",
1270 __func__, code, IPCThreadState::self()->getCallingPid());
1271 return INVALID_OPERATION;
1272 default:
1273 break;
1274 }
1275
1276 // make sure the following transactions come from system components
1277 switch (code) {
1278 case TRANSACTION_setDeviceConnectionState:
1279 case TRANSACTION_handleDeviceConfigChange:
1280 case TRANSACTION_setPhoneState:
1281 //FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1282 // case TRANSACTION_setForceUse:
1283 case TRANSACTION_initStreamVolume:
1284 case TRANSACTION_setStreamVolumeIndex:
1285 case TRANSACTION_setVolumeIndexForAttributes:
1286 case TRANSACTION_getStreamVolumeIndex:
1287 case TRANSACTION_getVolumeIndexForAttributes:
1288 case TRANSACTION_getMinVolumeIndexForAttributes:
1289 case TRANSACTION_getMaxVolumeIndexForAttributes:
1290 case TRANSACTION_isStreamActive:
1291 case TRANSACTION_isStreamActiveRemotely:
1292 case TRANSACTION_isSourceActive:
1293 case TRANSACTION_registerPolicyMixes:
1294 case TRANSACTION_setMasterMono:
1295 case TRANSACTION_getSurroundFormats:
1296 case TRANSACTION_getReportedSurroundFormats:
1297 case TRANSACTION_setSurroundFormatEnabled:
1298 case TRANSACTION_setAssistantServicesUids:
1299 case TRANSACTION_setActiveAssistantServicesUids:
1300 case TRANSACTION_setA11yServicesUids:
1301 case TRANSACTION_setUidDeviceAffinities:
1302 case TRANSACTION_removeUidDeviceAffinities:
1303 case TRANSACTION_setUserIdDeviceAffinities:
1304 case TRANSACTION_removeUserIdDeviceAffinities:
1305 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
1306 case TRANSACTION_listAudioVolumeGroups:
1307 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1308 case TRANSACTION_acquireSoundTriggerSession:
1309 case TRANSACTION_releaseSoundTriggerSession:
1310 case TRANSACTION_setRttEnabled:
1311 case TRANSACTION_isCallScreenModeSupported:
1312 case TRANSACTION_setDevicesRoleForStrategy:
1313 case TRANSACTION_setSupportedSystemUsages:
1314 case TRANSACTION_removeDevicesRoleForStrategy:
1315 case TRANSACTION_getDevicesForRoleAndStrategy:
1316 case TRANSACTION_getDevicesForAttributes:
1317 case TRANSACTION_setAllowedCapturePolicy:
1318 case TRANSACTION_onNewAudioModulesAvailable:
1319 case TRANSACTION_setCurrentImeUid:
1320 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1321 case TRANSACTION_setDevicesRoleForCapturePreset:
1322 case TRANSACTION_addDevicesRoleForCapturePreset:
1323 case TRANSACTION_removeDevicesRoleForCapturePreset:
1324 case TRANSACTION_clearDevicesRoleForCapturePreset:
1325 case TRANSACTION_getDevicesForRoleAndCapturePreset:
1326 case TRANSACTION_getSpatializer: {
1327 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1328 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1329 __func__, code, IPCThreadState::self()->getCallingPid(),
1330 IPCThreadState::self()->getCallingUid());
1331 return INVALID_OPERATION;
1332 }
1333 } break;
1334 default:
1335 break;
1336 }
1337
1338 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1339 mediautils::TimeCheck check(
1340 std::string("IAudioPolicyService::").append(methodName),
1341 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1342 if (timeout) {
1343 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1344 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1345 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1346 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1347 .record();
1348 } else {
1349 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1350 }
1351 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1352 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1353 true /* crashOnTimeout */);
1354
1355 switch (code) {
1356 case SHELL_COMMAND_TRANSACTION: {
1357 int in = data.readFileDescriptor();
1358 int out = data.readFileDescriptor();
1359 int err = data.readFileDescriptor();
1360 int argc = data.readInt32();
1361 Vector<String16> args;
1362 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1363 args.add(data.readString16());
1364 }
1365 sp<IBinder> unusedCallback;
1366 sp<IResultReceiver> resultReceiver;
1367 status_t status;
1368 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1369 return status;
1370 }
1371 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1372 return status;
1373 }
1374 status = shellCommand(in, out, err, args);
1375 if (resultReceiver != nullptr) {
1376 resultReceiver->send(status);
1377 }
1378 return NO_ERROR;
1379 }
1380 }
1381
1382 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1383 }
1384
1385 // ------------------- Shell command implementation -------------------
1386
1387 // NOTE: This is a remote API - make sure all args are validated
shellCommand(int in,int out,int err,Vector<String16> & args)1388 status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1389 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1390 return PERMISSION_DENIED;
1391 }
1392 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1393 return BAD_VALUE;
1394 }
1395 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
1396 return handleSetUidState(args, err);
1397 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
1398 return handleResetUidState(args, err);
1399 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
1400 return handleGetUidState(args, out, err);
1401 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1402 purgePermissionCache();
1403 return NO_ERROR;
1404 } else if (args.size() == 1 && args[0] == String16("help")) {
1405 printHelp(out);
1406 return NO_ERROR;
1407 }
1408 printHelp(err);
1409 return BAD_VALUE;
1410 }
1411
getUidForPackage(String16 packageName,int userId,uid_t & uid,int err)1412 static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1413 if (userId < 0) {
1414 ALOGE("Invalid user: %d", userId);
1415 dprintf(err, "Invalid user: %d\n", userId);
1416 return BAD_VALUE;
1417 }
1418
1419 PermissionController pc;
1420 uid = pc.getPackageUid(packageName, 0);
1421 if (uid <= 0) {
1422 ALOGE("Unknown package: '%s'", String8(packageName).string());
1423 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1424 return BAD_VALUE;
1425 }
1426
1427 uid = multiuser_get_uid(userId, uid);
1428 return NO_ERROR;
1429 }
1430
handleSetUidState(Vector<String16> & args,int err)1431 status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1432 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1433 if (!(args.size() == 3 || args.size() == 5)) {
1434 printHelp(err);
1435 return BAD_VALUE;
1436 }
1437
1438 bool active = false;
1439 if (args[2] == String16("active")) {
1440 active = true;
1441 } else if ((args[2] != String16("idle"))) {
1442 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1443 return BAD_VALUE;
1444 }
1445
1446 int userId = 0;
1447 if (args.size() >= 5 && args[3] == String16("--user")) {
1448 userId = atoi(String8(args[4]));
1449 }
1450
1451 uid_t uid;
1452 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1453 return BAD_VALUE;
1454 }
1455
1456 sp<UidPolicy> uidPolicy;
1457 {
1458 Mutex::Autolock _l(mLock);
1459 uidPolicy = mUidPolicy;
1460 }
1461 if (uidPolicy) {
1462 uidPolicy->addOverrideUid(uid, active);
1463 return NO_ERROR;
1464 }
1465 return NO_INIT;
1466 }
1467
handleResetUidState(Vector<String16> & args,int err)1468 status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
1469 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1470 if (!(args.size() == 2 || args.size() == 4)) {
1471 printHelp(err);
1472 return BAD_VALUE;
1473 }
1474
1475 int userId = 0;
1476 if (args.size() >= 4 && args[2] == String16("--user")) {
1477 userId = atoi(String8(args[3]));
1478 }
1479
1480 uid_t uid;
1481 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1482 return BAD_VALUE;
1483 }
1484
1485 sp<UidPolicy> uidPolicy;
1486 {
1487 Mutex::Autolock _l(mLock);
1488 uidPolicy = mUidPolicy;
1489 }
1490 if (uidPolicy) {
1491 uidPolicy->removeOverrideUid(uid);
1492 return NO_ERROR;
1493 }
1494 return NO_INIT;
1495 }
1496
handleGetUidState(Vector<String16> & args,int out,int err)1497 status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
1498 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1499 if (!(args.size() == 2 || args.size() == 4)) {
1500 printHelp(err);
1501 return BAD_VALUE;
1502 }
1503
1504 int userId = 0;
1505 if (args.size() >= 4 && args[2] == String16("--user")) {
1506 userId = atoi(String8(args[3]));
1507 }
1508
1509 uid_t uid;
1510 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1511 return BAD_VALUE;
1512 }
1513
1514 sp<UidPolicy> uidPolicy;
1515 {
1516 Mutex::Autolock _l(mLock);
1517 uidPolicy = mUidPolicy;
1518 }
1519 if (uidPolicy) {
1520 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1521 }
1522 return NO_INIT;
1523 }
1524
printHelp(int out)1525 status_t AudioPolicyService::printHelp(int out) {
1526 return dprintf(out, "Audio policy service commands:\n"
1527 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1528 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1529 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
1530 " help print this message\n");
1531 }
1532
1533 // ----------- AudioPolicyService::UidPolicy implementation ----------
1534
registerSelf()1535 void AudioPolicyService::UidPolicy::registerSelf() {
1536 status_t res = mAm.linkToDeath(this);
1537 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
1538 | ActivityManager::UID_OBSERVER_IDLE
1539 | ActivityManager::UID_OBSERVER_ACTIVE
1540 | ActivityManager::UID_OBSERVER_PROCSTATE,
1541 ActivityManager::PROCESS_STATE_UNKNOWN,
1542 String16("audioserver"));
1543 if (!res) {
1544 Mutex::Autolock _l(mLock);
1545 mObserverRegistered = true;
1546 } else {
1547 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
1548
1549 mAm.unregisterUidObserver(this);
1550 }
1551 }
1552
unregisterSelf()1553 void AudioPolicyService::UidPolicy::unregisterSelf() {
1554 mAm.unlinkToDeath(this);
1555 mAm.unregisterUidObserver(this);
1556 Mutex::Autolock _l(mLock);
1557 mObserverRegistered = false;
1558 }
1559
binderDied(__unused const wp<IBinder> & who)1560 void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1561 Mutex::Autolock _l(mLock);
1562 mCachedUids.clear();
1563 mObserverRegistered = false;
1564 }
1565
checkRegistered()1566 void AudioPolicyService::UidPolicy::checkRegistered() {
1567 bool needToReregister = false;
1568 {
1569 Mutex::Autolock _l(mLock);
1570 needToReregister = !mObserverRegistered;
1571 }
1572 if (needToReregister) {
1573 // Looks like ActivityManager has died previously, attempt to re-register.
1574 registerSelf();
1575 }
1576 }
1577
isUidActive(uid_t uid)1578 bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1579 if (isServiceUid(uid)) return true;
1580 checkRegistered();
1581 {
1582 Mutex::Autolock _l(mLock);
1583 auto overrideIter = mOverrideUids.find(uid);
1584 if (overrideIter != mOverrideUids.end()) {
1585 return overrideIter->second.first;
1586 }
1587 // In an absense of the ActivityManager, assume everything to be active.
1588 if (!mObserverRegistered) return true;
1589 auto cacheIter = mCachedUids.find(uid);
1590 if (cacheIter != mCachedUids.end()) {
1591 return cacheIter->second.first;
1592 }
1593 }
1594 ActivityManager am;
1595 bool active = am.isUidActive(uid, String16("audioserver"));
1596 {
1597 Mutex::Autolock _l(mLock);
1598 mCachedUids.insert(std::pair<uid_t,
1599 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1600 ActivityManager::PROCESS_STATE_UNKNOWN)));
1601 }
1602 return active;
1603 }
1604
getUidState(uid_t uid)1605 int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1606 if (isServiceUid(uid)) {
1607 return ActivityManager::PROCESS_STATE_TOP;
1608 }
1609 checkRegistered();
1610 {
1611 Mutex::Autolock _l(mLock);
1612 auto overrideIter = mOverrideUids.find(uid);
1613 if (overrideIter != mOverrideUids.end()) {
1614 if (overrideIter->second.first) {
1615 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1616 return overrideIter->second.second;
1617 } else {
1618 auto cacheIter = mCachedUids.find(uid);
1619 if (cacheIter != mCachedUids.end()) {
1620 return cacheIter->second.second;
1621 }
1622 }
1623 }
1624 return ActivityManager::PROCESS_STATE_UNKNOWN;
1625 }
1626 // In an absense of the ActivityManager, assume everything to be active.
1627 if (!mObserverRegistered) {
1628 return ActivityManager::PROCESS_STATE_TOP;
1629 }
1630 auto cacheIter = mCachedUids.find(uid);
1631 if (cacheIter != mCachedUids.end()) {
1632 if (cacheIter->second.first) {
1633 return cacheIter->second.second;
1634 } else {
1635 return ActivityManager::PROCESS_STATE_UNKNOWN;
1636 }
1637 }
1638 }
1639 ActivityManager am;
1640 bool active = am.isUidActive(uid, String16("audioserver"));
1641 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1642 if (active) {
1643 state = am.getUidProcessState(uid, String16("audioserver"));
1644 }
1645 {
1646 Mutex::Autolock _l(mLock);
1647 mCachedUids.insert(std::pair<uid_t,
1648 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1649 }
1650
1651 return state;
1652 }
1653
onUidActive(uid_t uid)1654 void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
1655 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
1656 }
1657
onUidGone(uid_t uid,__unused bool disabled)1658 void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
1659 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
1660 }
1661
onUidIdle(uid_t uid,__unused bool disabled)1662 void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
1663 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
1664 }
1665
onUidStateChanged(uid_t uid,int32_t procState,int64_t procStateSeq __unused,int32_t capability __unused)1666 void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1667 int32_t procState,
1668 int64_t procStateSeq __unused,
1669 int32_t capability __unused) {
1670 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1671 updateUid(&mCachedUids, uid, true, procState, true);
1672 }
1673 }
1674
onUidProcAdjChanged(uid_t uid __unused)1675 void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1676 }
1677
updateOverrideUid(uid_t uid,bool active,bool insert)1678 void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
1679 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1680 }
1681
notifyService()1682 void AudioPolicyService::UidPolicy::notifyService() {
1683 sp<AudioPolicyService> service = mService.promote();
1684 if (service != nullptr) {
1685 service->updateUidStates();
1686 }
1687 }
1688
updateUid(std::unordered_map<uid_t,std::pair<bool,int>> * uids,uid_t uid,bool active,int state,bool insert)1689 void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1690 std::pair<bool, int>> *uids,
1691 uid_t uid,
1692 bool active,
1693 int state,
1694 bool insert) {
1695 if (isServiceUid(uid)) {
1696 return;
1697 }
1698 bool wasActive = isUidActive(uid);
1699 int previousState = getUidState(uid);
1700 {
1701 Mutex::Autolock _l(mLock);
1702 updateUidLocked(uids, uid, active, state, insert);
1703 }
1704 if (wasActive != isUidActive(uid) || state != previousState) {
1705 notifyService();
1706 }
1707 }
1708
updateUidLocked(std::unordered_map<uid_t,std::pair<bool,int>> * uids,uid_t uid,bool active,int state,bool insert)1709 void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1710 std::pair<bool, int>> *uids,
1711 uid_t uid,
1712 bool active,
1713 int state,
1714 bool insert) {
1715 auto it = uids->find(uid);
1716 if (it != uids->end()) {
1717 if (insert) {
1718 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1719 it->second.first = active;
1720 }
1721 if (it->second.first) {
1722 it->second.second = state;
1723 } else {
1724 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1725 }
1726 } else {
1727 uids->erase(it);
1728 }
1729 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1730 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1731 std::pair<bool, int>(active, state)));
1732 }
1733 }
1734
isA11yOnTop()1735 bool AudioPolicyService::UidPolicy::isA11yOnTop() {
1736 for (const auto &uid : mCachedUids) {
1737 if (!isA11yUid(uid.first)) {
1738 continue;
1739 }
1740 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1741 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
1742 return true;
1743 }
1744 }
1745 return false;
1746 }
1747
isA11yUid(uid_t uid)1748 bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1749 {
1750 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1751 return it != mA11yUids.end();
1752 }
1753
setAssistantUids(const std::vector<uid_t> & uids)1754 void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1755 mAssistantUids.clear();
1756 mAssistantUids = uids;
1757 }
1758
isAssistantUid(uid_t uid)1759 bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1760 {
1761 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1762 return it != mAssistantUids.end();
1763 }
1764
setActiveAssistantUids(const std::vector<uid_t> & activeUids)1765 void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1766 mActiveAssistantUids = activeUids;
1767 }
1768
isActiveAssistantUid(uid_t uid)1769 bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1770 {
1771 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1772 mActiveAssistantUids.end(), uid);
1773 return it != mActiveAssistantUids.end();
1774 }
1775
dumpInternals(int fd)1776 void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1777 const size_t SIZE = 256;
1778 char buffer[SIZE];
1779 String8 result;
1780 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1781 snprintf(buffer, SIZE, "\t%s: \n", title);
1782 result.append(buffer);
1783 int counter = 0;
1784 if (uids.empty()) {
1785 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1786 result.append(buffer);
1787 return;
1788 }
1789 for (const auto &uid : uids) {
1790 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1791 result.append(buffer);
1792 }
1793 };
1794
1795 snprintf(buffer, SIZE, "UID Policy:\n");
1796 result.append(buffer);
1797 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1798 result.append(buffer);
1799
1800 appendUidsToResult("Assistants UIDs", mAssistantUids);
1801 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
1802
1803 appendUidsToResult("Accessibility UIDs", mA11yUids);
1804
1805 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1806 result.append(buffer);
1807
1808 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1809 result.append(buffer);
1810
1811 write(fd, result.string(), result.size());
1812 }
1813
1814 // ----------- AudioPolicyService::SensorPrivacyService implementation ----------
registerSelf()1815 void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1816 SensorPrivacyManager spm;
1817 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1818 spm.addSensorPrivacyListener(this);
1819 }
1820
unregisterSelf()1821 void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1822 SensorPrivacyManager spm;
1823 spm.removeSensorPrivacyListener(this);
1824 }
1825
isSensorPrivacyEnabled()1826 bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1827 return mSensorPrivacyEnabled;
1828 }
1829
onSensorPrivacyChanged(int toggleType __unused,int sensor __unused,bool enabled)1830 binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1831 int toggleType __unused, int sensor __unused, bool enabled) {
1832 mSensorPrivacyEnabled = enabled;
1833 sp<AudioPolicyService> service = mService.promote();
1834 if (service != nullptr) {
1835 service->updateUidStates();
1836 }
1837 return binder::Status::ok();
1838 }
1839
1840 // ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1841
1842 // static
1843 sp<AudioPolicyService::OpRecordAudioMonitor>
createIfNeeded(const AttributionSourceState & attributionSource,const audio_attributes_t & attr,wp<AudioCommandThread> commandThread)1844 AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1845 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1846 wp<AudioCommandThread> commandThread)
1847 {
1848 if (isAudioServerOrRootUid(attributionSource.uid)) {
1849 ALOGV("not silencing record for audio or root source %s",
1850 attributionSource.toString().c_str());
1851 return nullptr;
1852 }
1853
1854 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1855 ALOGD("not monitoring app op for uid %d and source %d",
1856 attributionSource.uid, attr.source);
1857 return nullptr;
1858 }
1859
1860 if (!attributionSource.packageName.has_value()
1861 || attributionSource.packageName.value().size() == 0) {
1862 return nullptr;
1863 }
1864 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1865 }
1866
OpRecordAudioMonitor(const AttributionSourceState & attributionSource,int32_t appOp,wp<AudioCommandThread> commandThread)1867 AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1868 const AttributionSourceState& attributionSource, int32_t appOp,
1869 wp<AudioCommandThread> commandThread) :
1870 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1871 mCommandThread(commandThread)
1872 {
1873 }
1874
~OpRecordAudioMonitor()1875 AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1876 {
1877 if (mOpCallback != 0) {
1878 mAppOpsManager.stopWatchingMode(mOpCallback);
1879 }
1880 mOpCallback.clear();
1881 }
1882
onFirstRef()1883 void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1884 {
1885 checkOp();
1886 mOpCallback = new RecordAudioOpCallback(this);
1887 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1888 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1889 // since it controls the mic permission for legacy apps.
1890 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1891 mAttributionSource.packageName.value_or(""))),
1892 mOpCallback);
1893 }
1894
hasOp() const1895 bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1896 return mHasOp.load();
1897 }
1898
1899 // Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1900 // is updated in AppOp callback and in onFirstRef()
1901 // Note this method is never called (and never to be) for audio server / root track
1902 // due to the UID in createIfNeeded(). As a result for those record track, it's:
1903 // - not called from constructor,
1904 // - not called from RecordAudioOpCallback because the callback is not installed in this case
checkOp(bool updateUidStates)1905 void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1906 {
1907 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1908 // since it controls the mic permission for legacy apps.
1909 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1910 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1911 mAttributionSource.packageName.value_or(""))));
1912 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1913 // verbose logging only log when appOp changed
1914 ALOGI_IF(hasIt != mHasOp.load(),
1915 "App op %d missing, %ssilencing record %s",
1916 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1917 mHasOp.store(hasIt);
1918
1919 if (updateUidStates) {
1920 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1921 if (commandThread != nullptr) {
1922 commandThread->updateUidStatesCommand();
1923 }
1924 }
1925 }
1926
RecordAudioOpCallback(const wp<OpRecordAudioMonitor> & monitor)1927 AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1928 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1929 { }
1930
opChanged(int32_t op,const String16 & packageName __unused)1931 void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1932 const String16& packageName __unused) {
1933 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1934 if (monitor != NULL) {
1935 if (op != monitor->getOp()) {
1936 return;
1937 }
1938 monitor->checkOp(true);
1939 }
1940 }
1941
1942
1943 // ----------- AudioPolicyService::AudioCommandThread implementation ----------
1944
AudioCommandThread(String8 name,const wp<AudioPolicyService> & service)1945 AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1946 const wp<AudioPolicyService>& service)
1947 : Thread(false), mName(name), mService(service)
1948 {
1949 }
1950
1951
~AudioCommandThread()1952 AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1953 {
1954 if (!mAudioCommands.isEmpty()) {
1955 release_wake_lock(mName.string());
1956 }
1957 mAudioCommands.clear();
1958 }
1959
onFirstRef()1960 void AudioPolicyService::AudioCommandThread::onFirstRef()
1961 {
1962 run(mName.string(), ANDROID_PRIORITY_AUDIO);
1963 }
1964
threadLoop()1965 bool AudioPolicyService::AudioCommandThread::threadLoop()
1966 {
1967 nsecs_t waitTime = -1;
1968
1969 mLock.lock();
1970 while (!exitPending())
1971 {
1972 sp<AudioPolicyService> svc;
1973 int numTimesBecameEmpty = 0;
1974 while (!mAudioCommands.isEmpty() && !exitPending()) {
1975 nsecs_t curTime = systemTime();
1976 // commands are sorted by increasing time stamp: execute them from index 0 and up
1977 if (mAudioCommands[0]->mTime <= curTime) {
1978 sp<AudioCommand> command = mAudioCommands[0];
1979 mAudioCommands.removeAt(0);
1980 if (mAudioCommands.isEmpty()) {
1981 ++numTimesBecameEmpty;
1982 }
1983 mLastCommand = command;
1984
1985 switch (command->mCommand) {
1986 case SET_VOLUME: {
1987 VolumeData *data = (VolumeData *)command->mParam.get();
1988 ALOGV("AudioCommandThread() processing set volume stream %d, \
1989 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
1990 mLock.unlock();
1991 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1992 data->mVolume,
1993 data->mIO);
1994 mLock.lock();
1995 }break;
1996 case SET_PARAMETERS: {
1997 ParametersData *data = (ParametersData *)command->mParam.get();
1998 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
1999 data->mKeyValuePairs.string(), data->mIO);
2000 mLock.unlock();
2001 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
2002 mLock.lock();
2003 }break;
2004 case SET_VOICE_VOLUME: {
2005 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2006 ALOGV("AudioCommandThread() processing set voice volume volume %f",
2007 data->mVolume);
2008 mLock.unlock();
2009 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
2010 mLock.lock();
2011 }break;
2012 case STOP_OUTPUT: {
2013 StopOutputData *data = (StopOutputData *)command->mParam.get();
2014 ALOGV("AudioCommandThread() processing stop output portId %d",
2015 data->mPortId);
2016 svc = mService.promote();
2017 if (svc == 0) {
2018 break;
2019 }
2020 mLock.unlock();
2021 svc->doStopOutput(data->mPortId);
2022 mLock.lock();
2023 }break;
2024 case RELEASE_OUTPUT: {
2025 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
2026 ALOGV("AudioCommandThread() processing release output portId %d",
2027 data->mPortId);
2028 svc = mService.promote();
2029 if (svc == 0) {
2030 break;
2031 }
2032 mLock.unlock();
2033 svc->doReleaseOutput(data->mPortId);
2034 mLock.lock();
2035 }break;
2036 case CREATE_AUDIO_PATCH: {
2037 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2038 ALOGV("AudioCommandThread() processing create audio patch");
2039 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2040 if (af == 0) {
2041 command->mStatus = PERMISSION_DENIED;
2042 } else {
2043 mLock.unlock();
2044 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
2045 mLock.lock();
2046 }
2047 } break;
2048 case RELEASE_AUDIO_PATCH: {
2049 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2050 ALOGV("AudioCommandThread() processing release audio patch");
2051 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2052 if (af == 0) {
2053 command->mStatus = PERMISSION_DENIED;
2054 } else {
2055 mLock.unlock();
2056 command->mStatus = af->releaseAudioPatch(data->mHandle);
2057 mLock.lock();
2058 }
2059 } break;
2060 case UPDATE_AUDIOPORT_LIST: {
2061 ALOGV("AudioCommandThread() processing update audio port list");
2062 svc = mService.promote();
2063 if (svc == 0) {
2064 break;
2065 }
2066 mLock.unlock();
2067 svc->doOnAudioPortListUpdate();
2068 mLock.lock();
2069 }break;
2070 case UPDATE_AUDIOPATCH_LIST: {
2071 ALOGV("AudioCommandThread() processing update audio patch list");
2072 svc = mService.promote();
2073 if (svc == 0) {
2074 break;
2075 }
2076 mLock.unlock();
2077 svc->doOnAudioPatchListUpdate();
2078 mLock.lock();
2079 }break;
2080 case CHANGED_AUDIOVOLUMEGROUP: {
2081 AudioVolumeGroupData *data =
2082 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2083 ALOGV("AudioCommandThread() processing update audio volume group");
2084 svc = mService.promote();
2085 if (svc == 0) {
2086 break;
2087 }
2088 mLock.unlock();
2089 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2090 mLock.lock();
2091 }break;
2092 case SET_AUDIOPORT_CONFIG: {
2093 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2094 ALOGV("AudioCommandThread() processing set port config");
2095 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2096 if (af == 0) {
2097 command->mStatus = PERMISSION_DENIED;
2098 } else {
2099 mLock.unlock();
2100 command->mStatus = af->setAudioPortConfig(&data->mConfig);
2101 mLock.lock();
2102 }
2103 } break;
2104 case DYN_POLICY_MIX_STATE_UPDATE: {
2105 DynPolicyMixStateUpdateData *data =
2106 (DynPolicyMixStateUpdateData *)command->mParam.get();
2107 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2108 data->mRegId.string(), data->mState);
2109 svc = mService.promote();
2110 if (svc == 0) {
2111 break;
2112 }
2113 mLock.unlock();
2114 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2115 mLock.lock();
2116 } break;
2117 case RECORDING_CONFIGURATION_UPDATE: {
2118 RecordingConfigurationUpdateData *data =
2119 (RecordingConfigurationUpdateData *)command->mParam.get();
2120 ALOGV("AudioCommandThread() processing recording configuration update");
2121 svc = mService.promote();
2122 if (svc == 0) {
2123 break;
2124 }
2125 mLock.unlock();
2126 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
2127 &data->mClientConfig, data->mClientEffects,
2128 &data->mDeviceConfig, data->mEffects,
2129 data->mPatchHandle, data->mSource);
2130 mLock.lock();
2131 } break;
2132 case SET_EFFECT_SUSPENDED: {
2133 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2134 ALOGV("AudioCommandThread() processing set effect suspended");
2135 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2136 if (af != 0) {
2137 mLock.unlock();
2138 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2139 mLock.lock();
2140 }
2141 } break;
2142 case AUDIO_MODULES_UPDATE: {
2143 ALOGV("AudioCommandThread() processing audio modules update");
2144 svc = mService.promote();
2145 if (svc == 0) {
2146 break;
2147 }
2148 mLock.unlock();
2149 svc->doOnNewAudioModulesAvailable();
2150 mLock.lock();
2151 } break;
2152 case ROUTING_UPDATED: {
2153 ALOGV("AudioCommandThread() processing routing update");
2154 svc = mService.promote();
2155 if (svc == 0) {
2156 break;
2157 }
2158 mLock.unlock();
2159 svc->doOnRoutingUpdated();
2160 mLock.lock();
2161 } break;
2162
2163 case UPDATE_UID_STATES: {
2164 ALOGV("AudioCommandThread() processing updateUID states");
2165 svc = mService.promote();
2166 if (svc == 0) {
2167 break;
2168 }
2169 mLock.unlock();
2170 svc->updateUidStates();
2171 mLock.lock();
2172 } break;
2173
2174 case CHECK_SPATIALIZER_OUTPUT: {
2175 ALOGV("AudioCommandThread() processing check spatializer");
2176 svc = mService.promote();
2177 if (svc == 0) {
2178 break;
2179 }
2180 mLock.unlock();
2181 svc->doOnCheckSpatializer();
2182 mLock.lock();
2183 } break;
2184
2185 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2186 ALOGV("AudioCommandThread() processing update spatializer tracks");
2187 svc = mService.promote();
2188 if (svc == 0) {
2189 break;
2190 }
2191 mLock.unlock();
2192 svc->doOnUpdateActiveSpatializerTracks();
2193 mLock.lock();
2194 } break;
2195
2196 case VOL_RANGE_INIT_REQUEST: {
2197 ALOGV("AudioCommandThread() processing volume range init request");
2198 svc = mService.promote();
2199 if (svc == 0) {
2200 break;
2201 }
2202 mLock.unlock();
2203 svc->doOnVolumeRangeInitRequest();
2204 mLock.lock();
2205 } break;
2206
2207 default:
2208 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
2209 }
2210 {
2211 Mutex::Autolock _l(command->mLock);
2212 if (command->mWaitStatus) {
2213 command->mWaitStatus = false;
2214 command->mCond.signal();
2215 }
2216 }
2217 waitTime = -1;
2218 // release mLock before releasing strong reference on the service as
2219 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2220 // acquires mLock.
2221 mLock.unlock();
2222 svc.clear();
2223 mLock.lock();
2224 } else {
2225 waitTime = mAudioCommands[0]->mTime - curTime;
2226 break;
2227 }
2228 }
2229
2230 // release delayed commands wake lock as many times as we made the queue is
2231 // empty during popping.
2232 while (numTimesBecameEmpty--) {
2233 release_wake_lock(mName.string());
2234 }
2235
2236 // At this stage we have either an empty command queue or the first command in the queue
2237 // has a finite delay. So unless we are exiting it is safe to wait.
2238 if (!exitPending()) {
2239 ALOGV("AudioCommandThread() going to sleep");
2240 if (waitTime == -1) {
2241 mWaitWorkCV.wait(mLock);
2242 } else {
2243 mWaitWorkCV.waitRelative(mLock, waitTime);
2244 }
2245 }
2246 }
2247 // release delayed commands wake lock before quitting
2248 if (!mAudioCommands.isEmpty()) {
2249 release_wake_lock(mName.string());
2250 }
2251 mLock.unlock();
2252 return false;
2253 }
2254
dump(int fd)2255 status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2256 {
2257 const size_t SIZE = 256;
2258 char buffer[SIZE];
2259 String8 result;
2260
2261 const bool locked = dumpTryLock(mLock);
2262 if (!locked) {
2263 String8 result2(kCmdDeadlockedString);
2264 write(fd, result2.string(), result2.size());
2265 }
2266
2267 snprintf(buffer, SIZE, "- Commands:\n");
2268 result = String8(buffer);
2269 result.append(" Command Time Wait pParam\n");
2270 for (size_t i = 0; i < mAudioCommands.size(); i++) {
2271 mAudioCommands[i]->dump(buffer, SIZE);
2272 result.append(buffer);
2273 }
2274 result.append(" Last Command\n");
2275 if (mLastCommand != 0) {
2276 mLastCommand->dump(buffer, SIZE);
2277 result.append(buffer);
2278 } else {
2279 result.append(" none\n");
2280 }
2281
2282 write(fd, result.string(), result.size());
2283
2284 dumpReleaseLock(mLock, locked);
2285
2286 return NO_ERROR;
2287 }
2288
volumeCommand(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delayMs)2289 status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
2290 float volume,
2291 audio_io_handle_t output,
2292 int delayMs)
2293 {
2294 sp<AudioCommand> command = new AudioCommand();
2295 command->mCommand = SET_VOLUME;
2296 sp<VolumeData> data = new VolumeData();
2297 data->mStream = stream;
2298 data->mVolume = volume;
2299 data->mIO = output;
2300 command->mParam = data;
2301 command->mWaitStatus = true;
2302 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
2303 stream, volume, output);
2304 return sendCommand(command, delayMs);
2305 }
2306
parametersCommand(audio_io_handle_t ioHandle,const char * keyValuePairs,int delayMs)2307 status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
2308 const char *keyValuePairs,
2309 int delayMs)
2310 {
2311 sp<AudioCommand> command = new AudioCommand();
2312 command->mCommand = SET_PARAMETERS;
2313 sp<ParametersData> data = new ParametersData();
2314 data->mIO = ioHandle;
2315 data->mKeyValuePairs = String8(keyValuePairs);
2316 command->mParam = data;
2317 command->mWaitStatus = true;
2318 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
2319 keyValuePairs, ioHandle, delayMs);
2320 return sendCommand(command, delayMs);
2321 }
2322
voiceVolumeCommand(float volume,int delayMs)2323 status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2324 {
2325 sp<AudioCommand> command = new AudioCommand();
2326 command->mCommand = SET_VOICE_VOLUME;
2327 sp<VoiceVolumeData> data = new VoiceVolumeData();
2328 data->mVolume = volume;
2329 command->mParam = data;
2330 command->mWaitStatus = true;
2331 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
2332 return sendCommand(command, delayMs);
2333 }
2334
setEffectSuspendedCommand(int effectId,audio_session_t sessionId,bool suspended)2335 void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2336 audio_session_t sessionId,
2337 bool suspended)
2338 {
2339 sp<AudioCommand> command = new AudioCommand();
2340 command->mCommand = SET_EFFECT_SUSPENDED;
2341 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2342 data->mEffectId = effectId;
2343 data->mSessionId = sessionId;
2344 data->mSuspended = suspended;
2345 command->mParam = data;
2346 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2347 effectId, sessionId, suspended);
2348 sendCommand(command);
2349 }
2350
2351
stopOutputCommand(audio_port_handle_t portId)2352 void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
2353 {
2354 sp<AudioCommand> command = new AudioCommand();
2355 command->mCommand = STOP_OUTPUT;
2356 sp<StopOutputData> data = new StopOutputData();
2357 data->mPortId = portId;
2358 command->mParam = data;
2359 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
2360 sendCommand(command);
2361 }
2362
releaseOutputCommand(audio_port_handle_t portId)2363 void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
2364 {
2365 sp<AudioCommand> command = new AudioCommand();
2366 command->mCommand = RELEASE_OUTPUT;
2367 sp<ReleaseOutputData> data = new ReleaseOutputData();
2368 data->mPortId = portId;
2369 command->mParam = data;
2370 ALOGV("AudioCommandThread() adding release output portId %d", portId);
2371 sendCommand(command);
2372 }
2373
createAudioPatchCommand(const struct audio_patch * patch,audio_patch_handle_t * handle,int delayMs)2374 status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2375 const struct audio_patch *patch,
2376 audio_patch_handle_t *handle,
2377 int delayMs)
2378 {
2379 status_t status = NO_ERROR;
2380
2381 sp<AudioCommand> command = new AudioCommand();
2382 command->mCommand = CREATE_AUDIO_PATCH;
2383 CreateAudioPatchData *data = new CreateAudioPatchData();
2384 data->mPatch = *patch;
2385 data->mHandle = *handle;
2386 command->mParam = data;
2387 command->mWaitStatus = true;
2388 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2389 status = sendCommand(command, delayMs);
2390 if (status == NO_ERROR) {
2391 *handle = data->mHandle;
2392 }
2393 return status;
2394 }
2395
releaseAudioPatchCommand(audio_patch_handle_t handle,int delayMs)2396 status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2397 int delayMs)
2398 {
2399 sp<AudioCommand> command = new AudioCommand();
2400 command->mCommand = RELEASE_AUDIO_PATCH;
2401 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2402 data->mHandle = handle;
2403 command->mParam = data;
2404 command->mWaitStatus = true;
2405 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2406 return sendCommand(command, delayMs);
2407 }
2408
updateAudioPortListCommand()2409 void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2410 {
2411 sp<AudioCommand> command = new AudioCommand();
2412 command->mCommand = UPDATE_AUDIOPORT_LIST;
2413 ALOGV("AudioCommandThread() adding update audio port list");
2414 sendCommand(command);
2415 }
2416
updateUidStatesCommand()2417 void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2418 {
2419 sp<AudioCommand> command = new AudioCommand();
2420 command->mCommand = UPDATE_UID_STATES;
2421 ALOGV("AudioCommandThread() adding update UID states");
2422 sendCommand(command);
2423 }
2424
updateAudioPatchListCommand()2425 void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2426 {
2427 sp<AudioCommand>command = new AudioCommand();
2428 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2429 ALOGV("AudioCommandThread() adding update audio patch list");
2430 sendCommand(command);
2431 }
2432
changeAudioVolumeGroupCommand(volume_group_t group,int flags)2433 void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2434 int flags)
2435 {
2436 sp<AudioCommand>command = new AudioCommand();
2437 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2438 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2439 data->mGroup = group;
2440 data->mFlags = flags;
2441 command->mParam = data;
2442 ALOGV("AudioCommandThread() adding audio volume group changed");
2443 sendCommand(command);
2444 }
2445
setAudioPortConfigCommand(const struct audio_port_config * config,int delayMs)2446 status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2447 const struct audio_port_config *config, int delayMs)
2448 {
2449 sp<AudioCommand> command = new AudioCommand();
2450 command->mCommand = SET_AUDIOPORT_CONFIG;
2451 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2452 data->mConfig = *config;
2453 command->mParam = data;
2454 command->mWaitStatus = true;
2455 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2456 return sendCommand(command, delayMs);
2457 }
2458
dynamicPolicyMixStateUpdateCommand(const String8 & regId,int32_t state)2459 void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
2460 const String8& regId, int32_t state)
2461 {
2462 sp<AudioCommand> command = new AudioCommand();
2463 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2464 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2465 data->mRegId = regId;
2466 data->mState = state;
2467 command->mParam = data;
2468 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2469 regId.string(), state);
2470 sendCommand(command);
2471 }
2472
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)2473 void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
2474 int event,
2475 const record_client_info_t *clientInfo,
2476 const audio_config_base_t *clientConfig,
2477 std::vector<effect_descriptor_t> clientEffects,
2478 const audio_config_base_t *deviceConfig,
2479 std::vector<effect_descriptor_t> effects,
2480 audio_patch_handle_t patchHandle,
2481 audio_source_t source)
2482 {
2483 sp<AudioCommand>command = new AudioCommand();
2484 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2485 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2486 data->mEvent = event;
2487 data->mClientInfo = *clientInfo;
2488 data->mClientConfig = *clientConfig;
2489 data->mClientEffects = clientEffects;
2490 data->mDeviceConfig = *deviceConfig;
2491 data->mEffects = effects;
2492 data->mPatchHandle = patchHandle;
2493 data->mSource = source;
2494 command->mParam = data;
2495 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2496 event, clientInfo->source, clientInfo->uid);
2497 sendCommand(command);
2498 }
2499
audioModulesUpdateCommand()2500 void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2501 {
2502 sp<AudioCommand> command = new AudioCommand();
2503 command->mCommand = AUDIO_MODULES_UPDATE;
2504 sendCommand(command);
2505 }
2506
routingChangedCommand()2507 void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2508 {
2509 sp<AudioCommand>command = new AudioCommand();
2510 command->mCommand = ROUTING_UPDATED;
2511 ALOGV("AudioCommandThread() adding routing update");
2512 sendCommand(command);
2513 }
2514
checkSpatializerCommand()2515 void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2516 {
2517 sp<AudioCommand>command = new AudioCommand();
2518 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
2519 ALOGV("AudioCommandThread() adding check spatializer");
2520 sendCommand(command);
2521 }
2522
updateActiveSpatializerTracksCommand()2523 void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2524 {
2525 sp<AudioCommand>command = new AudioCommand();
2526 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2527 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2528 sendCommand(command);
2529 }
2530
volRangeInitReqCommand()2531 void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2532 {
2533 sp<AudioCommand>command = new AudioCommand();
2534 command->mCommand = VOL_RANGE_INIT_REQUEST;
2535 ALOGV("AudioCommandThread() adding volume range init request");
2536 sendCommand(command);
2537 }
2538
sendCommand(sp<AudioCommand> & command,int delayMs)2539 status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2540 {
2541 {
2542 Mutex::Autolock _l(mLock);
2543 insertCommand_l(command, delayMs);
2544 mWaitWorkCV.signal();
2545 }
2546 Mutex::Autolock _l(command->mLock);
2547 while (command->mWaitStatus) {
2548 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2549 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2550 command->mStatus = TIMED_OUT;
2551 command->mWaitStatus = false;
2552 }
2553 }
2554 return command->mStatus;
2555 }
2556
2557 // insertCommand_l() must be called with mLock held
insertCommand_l(sp<AudioCommand> & command,int delayMs)2558 void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
2559 {
2560 ssize_t i; // not size_t because i will count down to -1
2561 Vector < sp<AudioCommand> > removedCommands;
2562 command->mTime = systemTime() + milliseconds(delayMs);
2563
2564 // acquire wake lock to make sure delayed commands are processed
2565 if (mAudioCommands.isEmpty()) {
2566 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2567 }
2568
2569 // check same pending commands with later time stamps and eliminate them
2570 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
2571 sp<AudioCommand> command2 = mAudioCommands[i];
2572 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2573 if (command2->mTime <= command->mTime) break;
2574
2575 // create audio patch or release audio patch commands are equivalent
2576 // with regard to filtering
2577 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2578 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2579 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2580 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2581 continue;
2582 }
2583 } else if (command2->mCommand != command->mCommand) continue;
2584
2585 switch (command->mCommand) {
2586 case SET_PARAMETERS: {
2587 ParametersData *data = (ParametersData *)command->mParam.get();
2588 ParametersData *data2 = (ParametersData *)command2->mParam.get();
2589 if (data->mIO != data2->mIO) break;
2590 ALOGV("Comparing parameter command %s to new command %s",
2591 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
2592 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2593 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2594 for (size_t j = 0; j < param.size(); j++) {
2595 String8 key;
2596 String8 value;
2597 param.getAt(j, key, value);
2598 for (size_t k = 0; k < param2.size(); k++) {
2599 String8 key2;
2600 String8 value2;
2601 param2.getAt(k, key2, value2);
2602 if (key2 == key) {
2603 param2.remove(key2);
2604 ALOGV("Filtering out parameter %s", key2.string());
2605 break;
2606 }
2607 }
2608 }
2609 // if all keys have been filtered out, remove the command.
2610 // otherwise, update the key value pairs
2611 if (param2.size() == 0) {
2612 removedCommands.add(command2);
2613 } else {
2614 data2->mKeyValuePairs = param2.toString();
2615 }
2616 command->mTime = command2->mTime;
2617 // force delayMs to non 0 so that code below does not request to wait for
2618 // command status as the command is now delayed
2619 delayMs = 1;
2620 } break;
2621
2622 case SET_VOLUME: {
2623 VolumeData *data = (VolumeData *)command->mParam.get();
2624 VolumeData *data2 = (VolumeData *)command2->mParam.get();
2625 if (data->mIO != data2->mIO) break;
2626 if (data->mStream != data2->mStream) break;
2627 ALOGV("Filtering out volume command on output %d for stream %d",
2628 data->mIO, data->mStream);
2629 removedCommands.add(command2);
2630 command->mTime = command2->mTime;
2631 // force delayMs to non 0 so that code below does not request to wait for
2632 // command status as the command is now delayed
2633 delayMs = 1;
2634 } break;
2635
2636 case SET_VOICE_VOLUME: {
2637 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2638 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2639 ALOGV("Filtering out voice volume command value %f replaced by %f",
2640 data2->mVolume, data->mVolume);
2641 removedCommands.add(command2);
2642 command->mTime = command2->mTime;
2643 // force delayMs to non 0 so that code below does not request to wait for
2644 // command status as the command is now delayed
2645 delayMs = 1;
2646 } break;
2647
2648 case CREATE_AUDIO_PATCH:
2649 case RELEASE_AUDIO_PATCH: {
2650 audio_patch_handle_t handle;
2651 struct audio_patch patch;
2652 if (command->mCommand == CREATE_AUDIO_PATCH) {
2653 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
2654 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
2655 } else {
2656 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
2657 memset(&patch, 0, sizeof(patch));
2658 }
2659 audio_patch_handle_t handle2;
2660 struct audio_patch patch2;
2661 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2662 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
2663 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
2664 } else {
2665 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
2666 memset(&patch2, 0, sizeof(patch2));
2667 }
2668 if (handle != handle2) break;
2669 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2670 same output. */
2671 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2672 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2673 bool isOutputDiff = false;
2674 if (patch.num_sources == patch2.num_sources) {
2675 for (unsigned count = 0; count < patch.num_sources; count++) {
2676 if (patch.sources[count].id != patch2.sources[count].id) {
2677 isOutputDiff = true;
2678 break;
2679 }
2680 }
2681 if (isOutputDiff)
2682 break;
2683 }
2684 }
2685 ALOGV("Filtering out %s audio patch command for handle %d",
2686 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2687 removedCommands.add(command2);
2688 command->mTime = command2->mTime;
2689 // force delayMs to non 0 so that code below does not request to wait for
2690 // command status as the command is now delayed
2691 delayMs = 1;
2692 } break;
2693
2694 case DYN_POLICY_MIX_STATE_UPDATE: {
2695
2696 } break;
2697
2698 case RECORDING_CONFIGURATION_UPDATE: {
2699
2700 } break;
2701
2702 case ROUTING_UPDATED: {
2703
2704 } break;
2705
2706 case VOL_RANGE_INIT_REQUEST: {
2707 // command may come from different requests, do not filter
2708 } break;
2709
2710 default:
2711 break;
2712 }
2713 }
2714
2715 // remove filtered commands
2716 for (size_t j = 0; j < removedCommands.size(); j++) {
2717 // removed commands always have time stamps greater than current command
2718 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
2719 if (mAudioCommands[k].get() == removedCommands[j].get()) {
2720 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
2721 mAudioCommands.removeAt(k);
2722 break;
2723 }
2724 }
2725 }
2726 removedCommands.clear();
2727
2728 // Disable wait for status if delay is not 0.
2729 // Except for create audio patch command because the returned patch handle
2730 // is needed by audio policy manager
2731 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
2732 command->mWaitStatus = false;
2733 }
2734
2735 // insert command at the right place according to its time stamp
2736 ALOGV("inserting command: %d at index %zd, num commands %zu",
2737 command->mCommand, i+1, mAudioCommands.size());
2738 mAudioCommands.insertAt(command, i + 1);
2739 }
2740
exit()2741 void AudioPolicyService::AudioCommandThread::exit()
2742 {
2743 ALOGV("AudioCommandThread::exit");
2744 {
2745 AutoMutex _l(mLock);
2746 requestExit();
2747 mWaitWorkCV.signal();
2748 }
2749 // Note that we can call it from the thread loop if all other references have been released
2750 // but it will safely return WOULD_BLOCK in this case
2751 requestExitAndWait();
2752 }
2753
dump(char * buffer,size_t size)2754 void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2755 {
2756 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2757 mCommand,
2758 (int)ns2s(mTime),
2759 (int)ns2ms(mTime)%1000,
2760 mWaitStatus,
2761 mParam.get());
2762 }
2763
2764 /******* helpers for the service_ops callbacks defined below *********/
setParameters(audio_io_handle_t ioHandle,const char * keyValuePairs,int delayMs)2765 void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2766 const char *keyValuePairs,
2767 int delayMs)
2768 {
2769 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
2770 delayMs);
2771 }
2772
setStreamVolume(audio_stream_type_t stream,float volume,audio_io_handle_t output,int delayMs)2773 int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2774 float volume,
2775 audio_io_handle_t output,
2776 int delayMs)
2777 {
2778 return (int)mAudioCommandThread->volumeCommand(stream, volume,
2779 output, delayMs);
2780 }
2781
setVoiceVolume(float volume,int delayMs)2782 int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2783 {
2784 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2785 }
2786
setEffectSuspended(int effectId,audio_session_t sessionId,bool suspended)2787 void AudioPolicyService::setEffectSuspended(int effectId,
2788 audio_session_t sessionId,
2789 bool suspended)
2790 {
2791 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2792 }
2793
onNewAudioModulesAvailable()2794 Status AudioPolicyService::onNewAudioModulesAvailable()
2795 {
2796 mOutputCommandThread->audioModulesUpdateCommand();
2797 return Status::ok();
2798 }
2799
2800
2801 extern "C" {
2802 audio_module_handle_t aps_load_hw_module(void *service __unused,
2803 const char *name);
2804 audio_io_handle_t aps_open_output(void *service __unused,
2805 audio_devices_t *pDevices,
2806 uint32_t *pSamplingRate,
2807 audio_format_t *pFormat,
2808 audio_channel_mask_t *pChannelMask,
2809 uint32_t *pLatencyMs,
2810 audio_output_flags_t flags);
2811
2812 audio_io_handle_t aps_open_output_on_module(void *service __unused,
2813 audio_module_handle_t module,
2814 audio_devices_t *pDevices,
2815 uint32_t *pSamplingRate,
2816 audio_format_t *pFormat,
2817 audio_channel_mask_t *pChannelMask,
2818 uint32_t *pLatencyMs,
2819 audio_output_flags_t flags,
2820 const audio_offload_info_t *offloadInfo);
2821 audio_io_handle_t aps_open_dup_output(void *service __unused,
2822 audio_io_handle_t output1,
2823 audio_io_handle_t output2);
2824 int aps_close_output(void *service __unused, audio_io_handle_t output);
2825 int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2826 int aps_restore_output(void *service __unused, audio_io_handle_t output);
2827 audio_io_handle_t aps_open_input(void *service __unused,
2828 audio_devices_t *pDevices,
2829 uint32_t *pSamplingRate,
2830 audio_format_t *pFormat,
2831 audio_channel_mask_t *pChannelMask,
2832 audio_in_acoustics_t acoustics __unused);
2833 audio_io_handle_t aps_open_input_on_module(void *service __unused,
2834 audio_module_handle_t module,
2835 audio_devices_t *pDevices,
2836 uint32_t *pSamplingRate,
2837 audio_format_t *pFormat,
2838 audio_channel_mask_t *pChannelMask);
2839 int aps_close_input(void *service __unused, audio_io_handle_t input);
2840 int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
2841 int aps_move_effects(void *service __unused, audio_session_t session,
2842 audio_io_handle_t src_output,
2843 audio_io_handle_t dst_output);
2844 char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2845 const char *keys);
2846 void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2847 const char *kv_pairs, int delay_ms);
2848 int aps_set_stream_volume(void *service, audio_stream_type_t stream,
2849 float volume, audio_io_handle_t output,
2850 int delay_ms);
2851 int aps_set_voice_volume(void *service, float volume, int delay_ms);
2852 };
2853
2854 } // namespace android
2855