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