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