blob: e95147edba55a551bd3f9438d6ad61348b7f6d06 [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
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
Glenn Kasten153b9fe2013-07-15 11:23:36 -070020#include "Configuration.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070021#undef __STRICT_ANSI__
22#define __STDINT_LIMITS
23#define __STDC_LIMIT_MACROS
24#include <stdint.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070025#include <sys/time.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053026#include <dlfcn.h>
Mikhail Naganov959e2d02019-03-28 11:08:19 -070027
28#include <audio_utils/clock.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070029#include <binder/IServiceManager.h>
30#include <utils/Log.h>
31#include <cutils/properties.h>
32#include <binder/IPCThreadState.h>
Svet Ganovf4ddfef2018-01-16 07:37:58 -080033#include <binder/PermissionController.h>
34#include <binder/IResultReceiver.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070035#include <utils/String16.h>
36#include <utils/threads.h>
Atneya Nair5b1ed642023-06-23 14:43:37 -070037#include "AudioRecordClient.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070038#include "AudioPolicyService.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070039#include <hardware_legacy/power.h>
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -080040#include <media/AidlConversion.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070041#include <media/AudioEffect.h>
Chih-Hung Hsiehc84d9d22014-11-14 13:33:34 -080042#include <media/AudioParameter.h>
Andy Hungc747c532022-03-07 21:41:14 -080043#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070044#include <mediautils/ServiceUtilities.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080045#include <mediautils/TimeCheck.h>
Michael Groovercfd28302018-12-11 19:16:46 -080046#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070047
Dima Zavin64760242011-05-11 14:15:23 -070048#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070049#include <system/audio_policy.h>
Mikhail Naganov68e3f642023-04-28 13:06:32 -070050#include <AudioPolicyConfig.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053051#include <AudioPolicyManager.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070052
Mathias Agopian65ab4712010-07-14 17:59:35 -070053namespace android {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080054using binder::Status;
Shunkai Yao49bc61f2023-10-10 19:31:10 +000055using media::audio::common::Spatialization;
Mathias Agopian65ab4712010-07-14 17:59:35 -070056
Glenn Kasten8dad0e32012-01-09 08:41:22 -080057static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
58static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053059static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
Mathias Agopian65ab4712010-07-14 17:59:35 -070060
Mikhail Naganov959e2d02019-03-28 11:08:19 -070061static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Mathias Agopian65ab4712010-07-14 17:59:35 -070062
Eric Laurent0ede8922014-05-09 18:04:42 -070063static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010064
Svet Ganovf4ddfef2018-01-16 07:37:58 -080065static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070066
Andy Hungc747c532022-03-07 21:41:14 -080067// Creates an association between Binder code to name for IAudioPolicyService.
68#define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
69BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
70BINDER_METHOD_ENTRY(setDeviceConnectionState) \
71BINDER_METHOD_ENTRY(getDeviceConnectionState) \
72BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
73BINDER_METHOD_ENTRY(setPhoneState) \
74BINDER_METHOD_ENTRY(setForceUse) \
75BINDER_METHOD_ENTRY(getForceUse) \
76BINDER_METHOD_ENTRY(getOutput) \
77BINDER_METHOD_ENTRY(getOutputForAttr) \
78BINDER_METHOD_ENTRY(startOutput) \
79BINDER_METHOD_ENTRY(stopOutput) \
80BINDER_METHOD_ENTRY(releaseOutput) \
81BINDER_METHOD_ENTRY(getInputForAttr) \
82BINDER_METHOD_ENTRY(startInput) \
83BINDER_METHOD_ENTRY(stopInput) \
84BINDER_METHOD_ENTRY(releaseInput) \
85BINDER_METHOD_ENTRY(initStreamVolume) \
86BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
87BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
88BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
90BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
91BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
92BINDER_METHOD_ENTRY(getStrategyForStream) \
93BINDER_METHOD_ENTRY(getDevicesForAttributes) \
94BINDER_METHOD_ENTRY(getOutputForEffect) \
95BINDER_METHOD_ENTRY(registerEffect) \
96BINDER_METHOD_ENTRY(unregisterEffect) \
97BINDER_METHOD_ENTRY(setEffectEnabled) \
98BINDER_METHOD_ENTRY(moveEffectsToIo) \
99BINDER_METHOD_ENTRY(isStreamActive) \
100BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
101BINDER_METHOD_ENTRY(isSourceActive) \
102BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
103BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
104BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
105BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
106BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
107BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
108BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
109BINDER_METHOD_ENTRY(getOffloadSupport) \
110BINDER_METHOD_ENTRY(isDirectOutputSupported) \
111BINDER_METHOD_ENTRY(listAudioPorts) \
112BINDER_METHOD_ENTRY(getAudioPort) \
113BINDER_METHOD_ENTRY(createAudioPatch) \
114BINDER_METHOD_ENTRY(releaseAudioPatch) \
115BINDER_METHOD_ENTRY(listAudioPatches) \
116BINDER_METHOD_ENTRY(setAudioPortConfig) \
117BINDER_METHOD_ENTRY(registerClient) \
118BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
119BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
120BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
121BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
122BINDER_METHOD_ENTRY(getPhoneState) \
123BINDER_METHOD_ENTRY(registerPolicyMixes) \
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200124BINDER_METHOD_ENTRY(updatePolicyMixes) \
Andy Hungc747c532022-03-07 21:41:14 -0800125BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
126BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
127BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
128BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
129BINDER_METHOD_ENTRY(startAudioSource) \
130BINDER_METHOD_ENTRY(stopAudioSource) \
131BINDER_METHOD_ENTRY(setMasterMono) \
132BINDER_METHOD_ENTRY(getMasterMono) \
133BINDER_METHOD_ENTRY(getStreamVolumeDB) \
134BINDER_METHOD_ENTRY(getSurroundFormats) \
135BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
136BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
137BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
138BINDER_METHOD_ENTRY(setAssistantServicesUids) \
139BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
140BINDER_METHOD_ENTRY(setA11yServicesUids) \
141BINDER_METHOD_ENTRY(setCurrentImeUid) \
142BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
143BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800144BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800145BINDER_METHOD_ENTRY(listAudioProductStrategies) \
146BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
147BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
148BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
149BINDER_METHOD_ENTRY(setRttEnabled) \
150BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
151BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
152BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000153BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800154BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
155BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
157BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
158BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
159BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
160BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
161BINDER_METHOD_ENTRY(getSpatializer) \
162BINDER_METHOD_ENTRY(canBeSpatialized) \
163BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000164BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
165BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
166BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
167BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
168BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100169BINDER_METHOD_ENTRY(getRegisteredPolicyMixes) \
170 \
Andy Hungc747c532022-03-07 21:41:14 -0800171// singleton for Binder Method Statistics for IAudioPolicyService
172static auto& getIAudioPolicyServiceStatistics() {
173 using Code = int;
174
175#pragma push_macro("BINDER_METHOD_ENTRY")
176#undef BINDER_METHOD_ENTRY
177#define BINDER_METHOD_ENTRY(ENTRY) \
178 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
179
180 static mediautils::MethodStatistics<Code> methodStatistics{
181 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
182 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
183 };
184#pragma pop_macro("BINDER_METHOD_ENTRY")
185
186 return methodStatistics;
187}
188
Mathias Agopian65ab4712010-07-14 17:59:35 -0700189// ----------------------------------------------------------------------------
190
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530191static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
192{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700193 AudioPolicyManager *apm = nullptr;
194 media::AudioPolicyConfig apmConfig;
195 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
196 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
197 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
198 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
199 "Only default engine is currently supported with the AIDL HAL");
200 apm = new AudioPolicyManager(config,
201 loadApmEngineLibraryAndCreateEngine(
202 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
203 clientInterface);
204 } else {
205 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
206 apm = new AudioPolicyManager(config,
207 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
208 clientInterface);
209 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530210 status_t status = apm->initialize();
211 if (status != NO_ERROR) {
212 delete apm;
213 apm = nullptr;
214 }
215 return apm;
216}
217
218static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
219{
220 delete interface;
221}
222// ----------------------------------------------------------------------------
223
Mathias Agopian65ab4712010-07-14 17:59:35 -0700224AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700225 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700226 mAudioPolicyManager(NULL),
227 mAudioPolicyClient(NULL),
228 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530229 mCaptureStateNotifier(false),
230 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100231 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
232 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800233 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530234}
235
236void AudioPolicyService::loadAudioPolicyManager()
237{
238 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
239 if (mLibraryHandle != nullptr) {
240 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
241 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
242 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
243 const char *lastError = dlerror();
244 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
245 __func__, lastError != nullptr ? lastError : "no error");
246
247 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
248 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
249 lastError = dlerror();
250 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
251 __func__, lastError != nullptr ? lastError : "no error");
252 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
253 unloadAudioPolicyManager();
254 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
255 }
256 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700257}
258
259void AudioPolicyService::onFirstRef()
260{
Andy Hungd47aca22022-03-15 11:50:51 -0700261 // Log an AudioPolicy "constructor" mediametrics event on first ref.
262 // This records the time it takes to load the audio modules and devices.
263 mediametrics::Defer defer([beginNs = systemTime()] {
264 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
265 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
266 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
267 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700268 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800269 audio_utils::lock_guard _l(mMutex);
Eric Laurent93575202011-01-18 18:39:02 -0800270
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700271 // start audio commands thread
272 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
273 // start output activity command thread
274 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700275
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700276 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530277
278 loadAudioPolicyManager();
279 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700280 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200281
bryant_liuba2b4392014-06-11 16:49:30 +0800282 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000283 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
Andy Hungd3595ed2023-12-19 15:34:46 -0800284 auto audioPolicyEffects = sp<AudioPolicyEffects>::make(effectsFactoryHal);
285 auto uidPolicy = sp<UidPolicy>::make(this);
286 auto sensorPrivacyPolicy = sp<SensorPrivacyPolicy>::make(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700287 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800288 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000290 mUidPolicy = uidPolicy;
291 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700292 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000293 uidPolicy->registerSelf();
294 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200295
Eric Laurent81dd0f52021-07-05 11:54:40 +0200296 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200297 if (mAudioPolicyManager != nullptr) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800298 audio_utils::lock_guard _l(mMutex);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200299 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
300 AudioDeviceTypeAddrVector devices;
301 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
302 if (hasSpatializer) {
Andy Hung1040da52023-12-06 20:59:06 -0800303 // Unlock as Spatializer::create() will use the callback and acquire the
304 // AudioPolicyService_Mutex.
Andy Hung79eacdb2023-11-30 19:34:24 -0800305 mMutex.unlock();
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000306 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Andy Hung79eacdb2023-11-30 19:34:24 -0800307 mMutex.lock();
Eric Laurent52b0bd52021-09-27 15:25:40 +0200308 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700309 if (mSpatializer == nullptr) {
310 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
311 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
312 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
313 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200314 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200315 AudioSystem::audioPolicyReady();
Andy Hungb08b3752024-01-09 19:05:23 -0800316}
317
318void AudioPolicyService::onAudioSystemReady() {
319 sp<AudioPolicyEffects> audioPolicyEffects;
320 {
321 audio_utils::lock_guard _l(mMutex);
322
323 audioPolicyEffects = mAudioPolicyEffects;
324 }
325 audioPolicyEffects->initDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700326}
327
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530328void AudioPolicyService::unloadAudioPolicyManager()
329{
330 ALOGV("%s ", __func__);
331 if (mLibraryHandle != nullptr) {
332 dlclose(mLibraryHandle);
333 }
334 mLibraryHandle = nullptr;
335 mCreateAudioPolicyManager = nullptr;
336 mDestroyAudioPolicyManager = nullptr;
337}
338
Mathias Agopian65ab4712010-07-14 17:59:35 -0700339AudioPolicyService::~AudioPolicyService()
340{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700341 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700342 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700343
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530344 mDestroyAudioPolicyManager(mAudioPolicyManager);
345 unloadAudioPolicyManager();
346
Eric Laurentdce54a12014-03-10 12:19:46 -0700347 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700348
349 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800350 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800351
352 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800353 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000354
355 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800356 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700357}
358
359// A notification client is always registered by AudioSystem when the client process
360// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800361Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700362{
Eric Laurent12590252015-08-21 18:40:20 -0700363 if (client == 0) {
364 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800365 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700366 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800367 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700368
369 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800370 pid_t pid = IPCThreadState::self()->getCallingPid();
371 int64_t token = ((int64_t)uid<<32) | pid;
372
373 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700374 sp<NotificationClient> notificationClient = new NotificationClient(this,
375 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800376 uid,
377 pid);
378 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700379
luochaojiang908c7d72018-06-21 14:58:04 +0800380 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700381
Marco Nelissenf8880202014-11-14 07:58:25 -0800382 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700383 binder->linkToDeath(notificationClient);
384 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800385 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700386}
387
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800388Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700389{
Andy Hung79eacdb2023-11-30 19:34:24 -0800390 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurente8726fe2015-06-26 09:39:24 -0700391
392 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800393 pid_t pid = IPCThreadState::self()->getCallingPid();
394 int64_t token = ((int64_t)uid<<32) | pid;
395
396 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800397 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700398 }
luochaojiang908c7d72018-06-21 14:58:04 +0800399 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800400 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700401}
402
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800403Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100404{
Andy Hung79eacdb2023-11-30 19:34:24 -0800405 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100406
407 uid_t uid = IPCThreadState::self()->getCallingUid();
408 pid_t pid = IPCThreadState::self()->getCallingPid();
409 int64_t token = ((int64_t)uid<<32) | pid;
410
411 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800412 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100413 }
414 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800415 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100416}
417
Eric Laurentb52c1522014-05-20 11:27:36 -0700418// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800419void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700420{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000421 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800422 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800423 audio_utils::lock_guard _l(mNotificationClientsMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800424 int64_t token = ((int64_t)uid<<32) | pid;
425 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800426 for (size_t i = 0; i < mNotificationClients.size(); i++) {
427 if (mNotificationClients.valueAt(i)->uid() == uid) {
428 hasSameUid = true;
429 break;
430 }
431 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000432 }
433 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800434 audio_utils::lock_guard _l(mMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800435 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700436 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700437 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700438 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800439 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700440}
441
442void AudioPolicyService::onAudioPortListUpdate()
443{
444 mOutputCommandThread->updateAudioPortListCommand();
445}
446
447void AudioPolicyService::doOnAudioPortListUpdate()
448{
Andy Hung79eacdb2023-11-30 19:34:24 -0800449 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700450 for (size_t i = 0; i < mNotificationClients.size(); i++) {
451 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
452 }
453}
454
455void AudioPolicyService::onAudioPatchListUpdate()
456{
457 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700458}
459
Eric Laurentb52c1522014-05-20 11:27:36 -0700460void AudioPolicyService::doOnAudioPatchListUpdate()
461{
Andy Hung79eacdb2023-11-30 19:34:24 -0800462 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700463 for (size_t i = 0; i < mNotificationClients.size(); i++) {
464 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
465 }
466}
467
François Gaffiecfe17322018-11-07 13:41:29 +0100468void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
469{
470 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
471}
472
473void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
474{
Andy Hung79eacdb2023-11-30 19:34:24 -0800475 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100476 for (size_t i = 0; i < mNotificationClients.size(); i++) {
477 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
478 }
479}
480
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700481void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700482{
483 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000484 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700485 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
486}
487
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700488void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700489{
Andy Hung79eacdb2023-11-30 19:34:24 -0800490 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700491 for (size_t i = 0; i < mNotificationClients.size(); i++) {
492 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
493 }
494}
495
Eric Laurenta9f86652018-11-28 17:23:11 -0800496void AudioPolicyService::onRecordingConfigurationUpdate(
497 int event,
498 const record_client_info_t *clientInfo,
499 const audio_config_base_t *clientConfig,
500 std::vector<effect_descriptor_t> clientEffects,
501 const audio_config_base_t *deviceConfig,
502 std::vector<effect_descriptor_t> effects,
503 audio_patch_handle_t patchHandle,
504 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800505{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800506 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800507 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800508}
509
Eric Laurenta9f86652018-11-28 17:23:11 -0800510void AudioPolicyService::doOnRecordingConfigurationUpdate(
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)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800519{
Andy Hung79eacdb2023-11-30 19:34:24 -0800520 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800521 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800522 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800523 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800524 }
525}
526
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700527void AudioPolicyService::onRoutingUpdated()
528{
529 mOutputCommandThread->routingChangedCommand();
530}
531
532void AudioPolicyService::doOnRoutingUpdated()
533{
Andy Hung79eacdb2023-11-30 19:34:24 -0800534 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700535 for (size_t i = 0; i < mNotificationClients.size(); i++) {
536 mNotificationClients.valueAt(i)->onRoutingUpdated();
537 }
538}
539
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000540void AudioPolicyService::onVolumeRangeInitRequest()
541{
542 mOutputCommandThread->volRangeInitReqCommand();
543}
544
545void AudioPolicyService::doOnVolumeRangeInitRequest()
546{
Andy Hung79eacdb2023-11-30 19:34:24 -0800547 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000548 for (size_t i = 0; i < mNotificationClients.size(); i++) {
549 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
550 }
551}
552
Eric Laurent81dd0f52021-07-05 11:54:40 +0200553void AudioPolicyService::onCheckSpatializer()
554{
Andy Hung79eacdb2023-11-30 19:34:24 -0800555 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200556 onCheckSpatializer_l();
557}
558
559void AudioPolicyService::onCheckSpatializer_l()
560{
561 if (mSpatializer != nullptr) {
562 mOutputCommandThread->checkSpatializerCommand();
563 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200564}
565
566void AudioPolicyService::doOnCheckSpatializer()
567{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200568 ALOGV("%s mSpatializer %p level %d",
569 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200570
Eric Laurent39095982021-08-24 18:29:27 +0200571 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200572 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000573 if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200574 audio_io_handle_t currentOutput = mSpatializer->getOutput();
575 audio_io_handle_t newOutput;
576 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
577 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200578
Andy Hung79eacdb2023-11-30 19:34:24 -0800579 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200580 status_t status =
581 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100582 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
583 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200584 if (status == NO_ERROR && currentOutput == newOutput) {
585 return;
586 }
Eric Laurent15903592022-02-24 20:44:36 +0100587 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Andy Hung79eacdb2023-11-30 19:34:24 -0800588 mMutex.unlock();
Eric Laurent39095982021-08-24 18:29:27 +0200589 // It is OK to call detachOutput() is none is already attached.
590 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200591 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
592 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200593 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800594 mMutex.lock();
Eric Laurent39095982021-08-24 18:29:27 +0200595 if (status != NO_ERROR) {
596 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
597 }
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000598 } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
599 mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200600 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200601
Eric Laurent39095982021-08-24 18:29:27 +0200602 if (output != AUDIO_IO_HANDLE_NONE) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800603 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200604 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200605 }
606 }
607 }
608}
609
Eric Laurent11094172022-04-05 18:27:42 +0200610size_t AudioPolicyService::countActiveClientsOnOutput_l(
611 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100612 size_t count = 0;
613 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
614 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200615 if (client->io == output && client->active
616 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100617 count++;
618 }
619 }
620 return count;
621}
622
623void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
624 if (mSpatializer == nullptr) {
625 return;
626 }
627 mOutputCommandThread->updateActiveSpatializerTracksCommand();
628}
629
630void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
631{
Eric Laurent21270b62022-07-04 15:11:29 +0200632 if (mSpatializer == nullptr) {
633 return;
634 }
635 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200636 size_t activeClients;
637 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800638 audio_utils::lock_guard _l(mMutex);
Eric Laurent21270b62022-07-04 15:11:29 +0200639 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100640 }
Eric Laurent21270b62022-07-04 15:11:29 +0200641 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100642}
643
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800644status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
645 audio_patch_handle_t *handle,
646 int delayMs)
647{
648 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
649}
650
651status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
652 int delayMs)
653{
654 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
655}
656
Eric Laurente1715a42014-05-20 11:30:42 -0700657status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
658 int delayMs)
659{
660 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
661}
662
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800663AudioPolicyService::NotificationClient::NotificationClient(
664 const sp<AudioPolicyService>& service,
665 const sp<media::IAudioPolicyServiceClient>& client,
666 uid_t uid,
667 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800668 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100669 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700670{
671}
672
673AudioPolicyService::NotificationClient::~NotificationClient()
674{
675}
676
677void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
678{
679 sp<NotificationClient> keep(this);
680 sp<AudioPolicyService> service = mService.promote();
681 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800682 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700683 }
684}
685
686void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
687{
Eric Laurente8726fe2015-06-26 09:39:24 -0700688 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700689 mAudioPolicyServiceClient->onAudioPortListUpdate();
690 }
691}
692
693void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
694{
Eric Laurente8726fe2015-06-26 09:39:24 -0700695 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700696 mAudioPolicyServiceClient->onAudioPatchListUpdate();
697 }
698}
Eric Laurent57dae992011-07-24 13:36:09 -0700699
Pattydd807582021-11-04 21:01:03 +0800700void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100701 int flags)
702{
703 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
704 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
705 }
706}
707
708
Jean-Michel Trivide801052015-04-14 19:10:14 -0700709void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700710 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700711{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700712 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800713 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
714 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800715 }
716}
717
718void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800719 int event,
720 const record_client_info_t *clientInfo,
721 const audio_config_base_t *clientConfig,
722 std::vector<effect_descriptor_t> clientEffects,
723 const audio_config_base_t *deviceConfig,
724 std::vector<effect_descriptor_t> effects,
725 audio_patch_handle_t patchHandle,
726 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800727{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700728 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800729 status_t status = [&]() -> status_t {
730 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
731 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
732 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700733 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700734 legacy2aidl_audio_config_base_t_AudioConfigBase(
735 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800736 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
737 convertContainer<std::vector<media::EffectDescriptor>>(
738 clientEffects,
739 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700740 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700741 legacy2aidl_audio_config_base_t_AudioConfigBase(
742 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800743 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
744 convertContainer<std::vector<media::EffectDescriptor>>(
745 effects,
746 legacy2aidl_effect_descriptor_t_EffectDescriptor));
747 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
748 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700749 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
750 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800751 return aidl_utils::statusTFromBinderStatus(
752 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
753 clientInfoAidl,
754 clientConfigAidl,
755 clientEffectsAidl,
756 deviceConfigAidl,
757 effectsAidl,
758 patchHandleAidl,
759 sourceAidl));
760 }();
761 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700762 }
763}
764
Eric Laurente8726fe2015-06-26 09:39:24 -0700765void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
766{
767 mAudioPortCallbacksEnabled = enabled;
768}
769
François Gaffiecfe17322018-11-07 13:41:29 +0100770void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
771{
772 mAudioVolumeGroupCallbacksEnabled = enabled;
773}
Eric Laurente8726fe2015-06-26 09:39:24 -0700774
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700775void AudioPolicyService::NotificationClient::onRoutingUpdated()
776{
777 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
778 mAudioPolicyServiceClient->onRoutingUpdated();
779 }
780}
781
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000782void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
783{
784 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
785 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
786 }
787}
788
Mathias Agopian65ab4712010-07-14 17:59:35 -0700789void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700790 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700791 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700792}
793
Andy Hung79eacdb2023-11-30 19:34:24 -0800794static void dumpReleaseLock(audio_utils::mutex& mutex, bool locked)
795 RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000796{
797 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700798}
799
800status_t AudioPolicyService::dumpInternals(int fd)
801{
802 const size_t SIZE = 256;
803 char buffer[SIZE];
804 String8 result;
805
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000806 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800807 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000808 std::stringstream msg;
809 size_t i = 0;
810 for (auto usage : mSupportedSystemUsages) {
811 if (i++ != 0) msg << ", ";
812 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
813 msg << strUsage;
814 } else {
815 msg << usage << " (unknown)";
816 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800817 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000818 if (i == 0) {
819 msg << "None";
820 }
821 msg << std::endl;
822 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800823
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000824 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800825
826 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700827 return NO_ERROR;
828}
829
Eric Laurente8c8b432018-10-17 10:08:02 -0700830void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800831{
Andy Hung79eacdb2023-11-30 19:34:24 -0800832 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700833 updateUidStates_l();
834}
835
836void AudioPolicyService::updateUidStates_l()
837{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800838// Go over all active clients and allow capture (does not force silence) in the
839// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800840// The client is in the active assistant list
841// AND is TOP
842// AND an accessibility service is TOP
843// AND source is either VOICE_RECOGNITION OR HOTWORD
844// OR there is no active privacy sensitive capture or call
845// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
846// AND source is VOICE_RECOGNITION OR HOTWORD
847// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800848// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700849// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800850// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800851// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800852// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
853// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800854// OR The client is an accessibility service
855// AND Is on TOP
856// AND the source is VOICE_RECOGNITION or HOTWORD
857// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700858// AND there is no active privacy sensitive capture or call
859// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800860// AND is on TOP
861// AND the source is VOICE_RECOGNITION or HOTWORD
862// OR the client source is virtual (remote submix, call audio TX or RX...)
863// OR the client source is HOTWORD
864// AND is on TOP
865// OR all active clients are using HOTWORD source
866// AND no call is active
867// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
868// OR the client is the current InputMethodService
869// AND a RTT call is active AND the source is VOICE_RECOGNITION
870// OR Any client
871// AND The assistant is not on TOP
872// AND is on TOP or latest started
873// AND there is no active privacy sensitive capture or call
874// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800875
Eric Laurent4e947da2019-10-17 15:24:06 -0700876
Eric Laurent4eb58f12018-12-07 16:41:02 -0800877 sp<AudioRecordClient> topActive;
878 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800879 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700880 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800881 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700882
Eric Laurenta46bedb2018-12-07 18:01:26 -0800883 nsecs_t topStartNs = 0;
884 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800885 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800886 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800887 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800888 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
889 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800890 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800891 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700892 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800893 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
894 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700895 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700896 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700897 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800898
Michael Groovercfd28302018-12-11 19:16:46 -0800899 // if Sensor Privacy is enabled then all recordings should be silenced.
900 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
901 silenceAllRecordings_l();
902 return;
903 }
904
Eric Laurente8c8b432018-10-17 10:08:02 -0700905 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
906 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000907 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
908 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800909 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700910 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800911 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700912
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700913 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700914 // clients which app is in IDLE state are not eligible for top active or
915 // latest active
916 if (appState == APP_STATE_IDLE) {
917 continue;
918 }
919
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700920 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700921 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800922 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700923 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700924 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800925 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800926 bool isPrivacySensitive =
927 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700928
Eric Laurentc21d5692020-02-25 10:24:36 -0800929 if (appState == APP_STATE_TOP) {
930 if (isPrivacySensitive) {
931 if (current->startTimeNs > topSensitiveStartNs) {
932 topSensitiveActive = current;
933 topSensitiveStartNs = current->startTimeNs;
934 }
935 } else {
936 if (current->startTimeNs > topStartNs) {
937 topActive = current;
938 topStartNs = current->startTimeNs;
939 }
940 }
941 if (isAssistant) {
942 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800943 if (isActiveAssistant) {
944 useActiveAssistantList = true;
945 } else if (!useActiveAssistantList) {
946 if (current->startTimeNs > latestAssistantStartNs) {
947 latestActiveAssistant = current;
948 latestAssistantStartNs = current->startTimeNs;
949 }
950 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800951 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800952 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800953 // Clients capturing for HOTWORD are not considered
954 // for latest active to avoid masking regular clients started before
955 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
956 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
957 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700958 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
959 // is marked latest sensitive active even if another app qualifies.
960 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700961 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700962 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700963 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000964 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700965 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700966 latestSensitiveActiveOrComm = current;
967 latestSensitiveStartNs = current->startTimeNs;
968 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800969 }
970 isSensitiveActive = true;
971 } else {
972 if (current->startTimeNs > latestStartNs) {
973 latestActive = current;
974 latestStartNs = current->startTimeNs;
975 }
976 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800977 }
978 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000979 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
980 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700981 onlyHotwordActive = false;
982 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100983 if (currentUid == mPhoneStateOwnerUid &&
984 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700985 isPhoneStateOwnerActive = true;
986 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800987 }
988
Eric Laurent1ff16a72019-03-14 18:35:04 -0700989 // if no active client with UI on Top, consider latest active as top
990 if (topActive == nullptr) {
991 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800992 topStartNs = latestStartNs;
993 }
994 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700995 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800996 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700997 } else if (latestSensitiveActiveOrComm != nullptr) {
998 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
999 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001000 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +00001001 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001002 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -07001003 topSensitiveActive = latestSensitiveActiveOrComm;
1004 topSensitiveStartNs = latestSensitiveStartNs;
1005 }
Eric Laurentc21d5692020-02-25 10:24:36 -08001006 }
1007
1008 // If both privacy sensitive and regular capture are active:
1009 // if the regular capture is privileged
1010 // allow concurrency
1011 // else
1012 // favor the privacy sensitive case
1013 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001014 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001015 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001016 }
1017
1018 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1019 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001020 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001021 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001022 if (!current->active) {
1023 continue;
1024 }
1025
Eric Laurent4eb58f12018-12-07 16:41:02 -08001026 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001027 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001028 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001029 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001030 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001031 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1032 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001033
Andy Hung79eacdb2023-11-30 19:34:24 -08001034 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mMutex) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001035 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001036 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001037 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001038 bool canCaptureCommunication = recordClient->canCaptureOutput
1039 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001040 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001041 return !(isInCall && !canCaptureCall)
1042 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001043 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001044
1045 // By default allow capture if:
1046 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001047 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001048 // AND there is no active privacy sensitive capture or call
1049 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001050 bool allowSensitiveCapture =
1051 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001052 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001053 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001054 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001055 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001056
Eric Laurented726cc2021-07-01 14:26:41 +02001057 if (!current->hasOp()) {
1058 // Never allow capture if app op is denied
1059 allowCapture = false;
1060 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001061 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1062 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001063 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001064 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001065 // Active assistant list is not being used
1066 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001067 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001068 // OR there is no active privacy sensitive capture or call
1069 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1070 // AND is latest TOP assistant AND
1071 // uses VOICE_RECOGNITION OR uses HOTWORD
1072 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001073 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001074 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001075 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001076 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001077 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001078 && canCaptureIfInCallOrCommunication(current)) {
1079 if (isTopOrLatestAssistant
1080 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1081 || source == AUDIO_SOURCE_HOTWORD)) {
1082 allowCapture = true;
1083 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1084 allowCapture = true;
1085 }
1086 }
1087 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1088 // For assistant on active list and on top allow capture if:
1089 // An accessibility service is on TOP
1090 // AND the source is VOICE_RECOGNITION or HOTWORD
1091 // OR there is no active privacy sensitive capture or call
1092 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1093 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1094 if (isA11yOnTop) {
1095 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1096 allowCapture = true;
1097 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001098 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001099 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001100 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1101 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001102 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001103 }
1104 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001105 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001106 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001107 // The assistant is not on TOP
1108 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001109 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001110 // OR
1111 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1112 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001113 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001114 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001115 allowCapture = true;
1116 }
Eric Laurent589171c2019-07-25 18:04:29 -07001117 if (isA11yOnTop) {
1118 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1119 allowCapture = true;
1120 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001121 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001122 } else if (source == AUDIO_SOURCE_HOTWORD) {
1123 // For HOTWORD source allow capture when not on TOP if:
1124 // All active clients are using HOTWORD source
1125 // AND no call is active
1126 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001127 if (onlyHotwordActive
1128 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001129 allowCapture = true;
1130 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001131 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001132 // For current InputMethodService allow capture if:
1133 // A RTT call is active AND the source is VOICE_RECOGNITION
1134 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1135 allowCapture = true;
1136 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001137 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001138 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001139 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001140 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001141 }
1142}
1143
Michael Groovercfd28302018-12-11 19:16:46 -08001144void AudioPolicyService::silenceAllRecordings_l() {
1145 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1146 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001147 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001148 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001149 }
Michael Groovercfd28302018-12-11 19:16:46 -08001150 }
1151}
1152
Eric Laurente8c8b432018-10-17 10:08:02 -07001153/* static */
1154app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001155
1156 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001157 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001158 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1159 // include persistent services
1160 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001161 }
1162 return APP_STATE_FOREGROUND;
1163}
1164
Eric Laurent4eb58f12018-12-07 16:41:02 -08001165/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001166bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001167{
1168 switch (source) {
1169 case AUDIO_SOURCE_VOICE_UPLINK:
1170 case AUDIO_SOURCE_VOICE_DOWNLINK:
1171 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001172 case AUDIO_SOURCE_REMOTE_SUBMIX:
1173 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001174 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001175 return true;
1176 default:
1177 break;
1178 }
1179 return false;
1180}
1181
Eric Laurent8c7ef892021-06-10 13:32:16 +02001182void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001183{
1184 AutoCallerClear acc;
1185
1186 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001187 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001188 }
1189 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1190 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001191 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001192 if (client->silenced != silenced) {
1193 if (client->active) {
1194 if (silenced) {
1195 finishRecording(client->attributionSource, client->attributes.source);
1196 } else {
1197 std::stringstream msg;
1198 msg << "Audio recording un-silenced on session " << client->session;
1199 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1200 client->attributes.source)) {
1201 silenced = true;
1202 }
1203 }
1204 }
1205 af->setRecordSilenced(client->portId, silenced);
1206 client->silenced = silenced;
1207 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001208 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001209}
1210
Glenn Kasten0f11b512014-01-31 16:18:54 -08001211status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Andy Hung79eacdb2023-11-30 19:34:24 -08001212NO_THREAD_SAFETY_ANALYSIS // update for trylock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001213{
Glenn Kasten44deb052012-02-05 18:09:08 -08001214 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215 dumpPermissionDenial(fd);
1216 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001217 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001218 if (!locked) {
1219 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001220 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001221 }
1222
1223 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001224
1225 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001226 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001227 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001228 mAudioCommandThread->dump(fd);
1229 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001230
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001231 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001232 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001233 if (mOutputCommandThread != 0) {
1234 mOutputCommandThread->dump(fd);
1235 }
1236
Eric Laurentdce54a12014-03-10 12:19:46 -07001237 if (mAudioPolicyManager) {
1238 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001239 } else {
1240 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001241 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001242 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001243
Kevin Rocard8be94972019-02-22 13:26:25 -08001244 mPackageManager.dump(fd);
1245
Andy Hung79eacdb2023-11-30 19:34:24 -08001246 dumpReleaseLock(mMutex, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001247
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001248 if (mSpatializer != nullptr) {
1249 std::string dumpString = mSpatializer->toString(1 /* level */);
1250 write(fd, dumpString.c_str(), dumpString.size());
1251 } else {
1252 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1253 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1254 }
1255
Andy Hungc747c532022-03-07 21:41:14 -08001256 {
1257 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1258 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1259 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1260 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001261 }
1262 return NO_ERROR;
1263}
1264
1265status_t AudioPolicyService::dumpPermissionDenial(int fd)
1266{
1267 const size_t SIZE = 256;
1268 char buffer[SIZE];
1269 String8 result;
1270 snprintf(buffer, SIZE, "Permission Denial: "
1271 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1272 IPCThreadState::self()->getCallingPid(),
1273 IPCThreadState::self()->getCallingUid());
1274 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001275 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001276 return NO_ERROR;
1277}
1278
1279status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001280 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001281 // make sure transactions reserved to AudioFlinger do not come from other processes
1282 switch (code) {
1283 case TRANSACTION_startOutput:
1284 case TRANSACTION_stopOutput:
1285 case TRANSACTION_releaseOutput:
1286 case TRANSACTION_getInputForAttr:
1287 case TRANSACTION_startInput:
1288 case TRANSACTION_stopInput:
1289 case TRANSACTION_releaseInput:
1290 case TRANSACTION_getOutputForEffect:
1291 case TRANSACTION_registerEffect:
1292 case TRANSACTION_unregisterEffect:
1293 case TRANSACTION_setEffectEnabled:
1294 case TRANSACTION_getStrategyForStream:
1295 case TRANSACTION_getOutputForAttr:
1296 case TRANSACTION_moveEffectsToIo:
1297 ALOGW("%s: transaction %d received from PID %d",
1298 __func__, code, IPCThreadState::self()->getCallingPid());
1299 return INVALID_OPERATION;
1300 default:
1301 break;
1302 }
1303
1304 // make sure the following transactions come from system components
1305 switch (code) {
1306 case TRANSACTION_setDeviceConnectionState:
1307 case TRANSACTION_handleDeviceConfigChange:
1308 case TRANSACTION_setPhoneState:
1309//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1310// case TRANSACTION_setForceUse:
1311 case TRANSACTION_initStreamVolume:
1312 case TRANSACTION_setStreamVolumeIndex:
1313 case TRANSACTION_setVolumeIndexForAttributes:
1314 case TRANSACTION_getStreamVolumeIndex:
1315 case TRANSACTION_getVolumeIndexForAttributes:
1316 case TRANSACTION_getMinVolumeIndexForAttributes:
1317 case TRANSACTION_getMaxVolumeIndexForAttributes:
1318 case TRANSACTION_isStreamActive:
1319 case TRANSACTION_isStreamActiveRemotely:
1320 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001321 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001322 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001323 case TRANSACTION_setMasterMono:
1324 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001325 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001326 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001327 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001328 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001329 case TRANSACTION_setA11yServicesUids:
1330 case TRANSACTION_setUidDeviceAffinities:
1331 case TRANSACTION_removeUidDeviceAffinities:
1332 case TRANSACTION_setUserIdDeviceAffinities:
1333 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001334 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001335 case TRANSACTION_listAudioVolumeGroups:
1336 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1337 case TRANSACTION_acquireSoundTriggerSession:
1338 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001339 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001340 case TRANSACTION_setRttEnabled:
1341 case TRANSACTION_isCallScreenModeSupported:
1342 case TRANSACTION_setDevicesRoleForStrategy:
1343 case TRANSACTION_setSupportedSystemUsages:
1344 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001345 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001346 case TRANSACTION_getDevicesForRoleAndStrategy:
1347 case TRANSACTION_getDevicesForAttributes:
1348 case TRANSACTION_setAllowedCapturePolicy:
1349 case TRANSACTION_onNewAudioModulesAvailable:
1350 case TRANSACTION_setCurrentImeUid:
1351 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1352 case TRANSACTION_setDevicesRoleForCapturePreset:
1353 case TRANSACTION_addDevicesRoleForCapturePreset:
1354 case TRANSACTION_removeDevicesRoleForCapturePreset:
1355 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001356 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001357 case TRANSACTION_getSpatializer:
1358 case TRANSACTION_setPreferredMixerAttributes:
Marvin Raminbdefaf02023-11-01 09:10:32 +01001359 case TRANSACTION_clearPreferredMixerAttributes:
1360 case TRANSACTION_getRegisteredPolicyMixes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001361 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1362 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1363 __func__, code, IPCThreadState::self()->getCallingPid(),
1364 IPCThreadState::self()->getCallingUid());
1365 return INVALID_OPERATION;
1366 }
1367 } break;
1368 default:
1369 break;
1370 }
1371
Andy Hungc747c532022-03-07 21:41:14 -08001372 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1373 mediautils::TimeCheck check(
1374 std::string("IAudioPolicyService::").append(methodName),
1375 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1376 if (timeout) {
1377 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1378 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1379 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1380 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1381 .record();
1382 } else {
1383 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1384 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001385 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1386 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1387 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001388
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001389 switch (code) {
1390 case SHELL_COMMAND_TRANSACTION: {
1391 int in = data.readFileDescriptor();
1392 int out = data.readFileDescriptor();
1393 int err = data.readFileDescriptor();
1394 int argc = data.readInt32();
1395 Vector<String16> args;
1396 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1397 args.add(data.readString16());
1398 }
1399 sp<IBinder> unusedCallback;
1400 sp<IResultReceiver> resultReceiver;
1401 status_t status;
1402 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1403 return status;
1404 }
1405 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1406 return status;
1407 }
1408 status = shellCommand(in, out, err, args);
1409 if (resultReceiver != nullptr) {
1410 resultReceiver->send(status);
1411 }
1412 return NO_ERROR;
1413 }
1414 }
1415
Mathias Agopian65ab4712010-07-14 17:59:35 -07001416 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1417}
1418
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001419// ------------------- Shell command implementation -------------------
1420
1421// NOTE: This is a remote API - make sure all args are validated
1422status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1423 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1424 return PERMISSION_DENIED;
1425 }
1426 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1427 return BAD_VALUE;
1428 }
jovanakbe066e12019-09-02 11:54:39 -07001429 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001430 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001431 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001432 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001433 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001434 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001435 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1436 purgePermissionCache();
1437 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001438 } else if (args.size() == 1 && args[0] == String16("help")) {
1439 printHelp(out);
1440 return NO_ERROR;
1441 }
1442 printHelp(err);
1443 return BAD_VALUE;
1444}
1445
jovanakbe066e12019-09-02 11:54:39 -07001446static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1447 if (userId < 0) {
1448 ALOGE("Invalid user: %d", userId);
1449 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001450 return BAD_VALUE;
1451 }
jovanakbe066e12019-09-02 11:54:39 -07001452
1453 PermissionController pc;
1454 uid = pc.getPackageUid(packageName, 0);
1455 if (uid <= 0) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001456 ALOGE("Unknown package: '%s'", String8(packageName).c_str());
1457 dprintf(err, "Unknown package: '%s'\n", String8(packageName).c_str());
jovanakbe066e12019-09-02 11:54:39 -07001458 return BAD_VALUE;
1459 }
1460
1461 uid = multiuser_get_uid(userId, uid);
1462 return NO_ERROR;
1463}
1464
1465status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1466 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1467 if (!(args.size() == 3 || args.size() == 5)) {
1468 printHelp(err);
1469 return BAD_VALUE;
1470 }
1471
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001472 bool active = false;
1473 if (args[2] == String16("active")) {
1474 active = true;
1475 } else if ((args[2] != String16("idle"))) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001476 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).c_str());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001477 return BAD_VALUE;
1478 }
jovanakbe066e12019-09-02 11:54:39 -07001479
1480 int userId = 0;
1481 if (args.size() >= 5 && args[3] == String16("--user")) {
1482 userId = atoi(String8(args[4]));
1483 }
1484
1485 uid_t uid;
1486 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1487 return BAD_VALUE;
1488 }
1489
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001490 sp<UidPolicy> uidPolicy;
1491 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001492 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001493 uidPolicy = mUidPolicy;
1494 }
1495 if (uidPolicy) {
1496 uidPolicy->addOverrideUid(uid, active);
1497 return NO_ERROR;
1498 }
1499 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001500}
1501
1502status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001503 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1504 if (!(args.size() == 2 || args.size() == 4)) {
1505 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001506 return BAD_VALUE;
1507 }
jovanakbe066e12019-09-02 11:54:39 -07001508
1509 int userId = 0;
1510 if (args.size() >= 4 && args[2] == String16("--user")) {
1511 userId = atoi(String8(args[3]));
1512 }
1513
1514 uid_t uid;
1515 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1516 return BAD_VALUE;
1517 }
1518
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001519 sp<UidPolicy> uidPolicy;
1520 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001521 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001522 uidPolicy = mUidPolicy;
1523 }
1524 if (uidPolicy) {
1525 uidPolicy->removeOverrideUid(uid);
1526 return NO_ERROR;
1527 }
1528 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001529}
1530
1531status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001532 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1533 if (!(args.size() == 2 || args.size() == 4)) {
1534 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001535 return BAD_VALUE;
1536 }
jovanakbe066e12019-09-02 11:54:39 -07001537
1538 int userId = 0;
1539 if (args.size() >= 4 && args[2] == String16("--user")) {
1540 userId = atoi(String8(args[3]));
1541 }
1542
1543 uid_t uid;
1544 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1545 return BAD_VALUE;
1546 }
1547
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001548 sp<UidPolicy> uidPolicy;
1549 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001550 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001551 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001552 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001553 if (uidPolicy) {
1554 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1555 }
1556 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001557}
1558
1559status_t AudioPolicyService::printHelp(int out) {
1560 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001561 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1562 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1563 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001564 " help print this message\n");
1565}
1566
Eric Laurent0d13fea2022-11-04 17:12:08 +01001567status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1568 const audio_config_base_t& config,
1569 const audio_output_flags_t flags) {
1570 return mUsecaseValidator->registerStream(output, config, flags);
1571}
1572
1573status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1574 return mUsecaseValidator->unregisterStream(output);
1575}
1576
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001577// ----------- AudioPolicyService::UidPolicy implementation ----------
1578
1579void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001580 status_t res = mAm.linkToDeath(this);
1581 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001582 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001583 | ActivityManager::UID_OBSERVER_ACTIVE
1584 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001585 ActivityManager::PROCESS_STATE_UNKNOWN,
1586 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001587 if (!res) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001588 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001589 mObserverRegistered = true;
1590 } else {
1591 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001592
Steven Moreland2f348142019-07-02 15:59:07 -07001593 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001594 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001595}
1596
1597void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001598 mAm.unlinkToDeath(this);
1599 mAm.unregisterUidObserver(this);
Andy Hung79eacdb2023-11-30 19:34:24 -08001600 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001601 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001602}
1603
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001604void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001605 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001606 mCachedUids.clear();
1607 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001608}
1609
Eric Laurente8c8b432018-10-17 10:08:02 -07001610void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001611 bool needToReregister = false;
1612 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001613 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001614 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001615 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001616 if (needToReregister) {
1617 // Looks like ActivityManager has died previously, attempt to re-register.
1618 registerSelf();
1619 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001620}
1621
1622bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1623 if (isServiceUid(uid)) return true;
1624 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001625 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001626 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001627 auto overrideIter = mOverrideUids.find(uid);
1628 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001629 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001630 }
1631 // In an absense of the ActivityManager, assume everything to be active.
1632 if (!mObserverRegistered) return true;
1633 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001634 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001635 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001636 }
1637 }
1638 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001639 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001640 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001641 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001642 mCachedUids.insert(std::pair<uid_t,
1643 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1644 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001645 }
1646 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001647}
1648
Eric Laurente8c8b432018-10-17 10:08:02 -07001649int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1650 if (isServiceUid(uid)) {
1651 return ActivityManager::PROCESS_STATE_TOP;
1652 }
1653 checkRegistered();
1654 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001655 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001656 auto overrideIter = mOverrideUids.find(uid);
1657 if (overrideIter != mOverrideUids.end()) {
1658 if (overrideIter->second.first) {
1659 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1660 return overrideIter->second.second;
1661 } else {
1662 auto cacheIter = mCachedUids.find(uid);
1663 if (cacheIter != mCachedUids.end()) {
1664 return cacheIter->second.second;
1665 }
1666 }
1667 }
1668 return ActivityManager::PROCESS_STATE_UNKNOWN;
1669 }
1670 // In an absense of the ActivityManager, assume everything to be active.
1671 if (!mObserverRegistered) {
1672 return ActivityManager::PROCESS_STATE_TOP;
1673 }
1674 auto cacheIter = mCachedUids.find(uid);
1675 if (cacheIter != mCachedUids.end()) {
1676 if (cacheIter->second.first) {
1677 return cacheIter->second.second;
1678 } else {
1679 return ActivityManager::PROCESS_STATE_UNKNOWN;
1680 }
1681 }
1682 }
1683 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001684 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001685 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1686 if (active) {
1687 state = am.getUidProcessState(uid, String16("audioserver"));
1688 }
1689 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001690 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001691 mCachedUids.insert(std::pair<uid_t,
1692 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1693 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001694
Eric Laurente8c8b432018-10-17 10:08:02 -07001695 return state;
1696}
1697
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001698void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001699 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001700}
1701
1702void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001703 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001704}
1705
1706void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001707 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001708}
1709
Eric Laurente8c8b432018-10-17 10:08:02 -07001710void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1711 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001712 int64_t procStateSeq __unused,
1713 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001714 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1715 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001716 }
1717}
1718
Austin Borgerdddb7552023-03-30 17:53:01 -07001719void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001720}
1721
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001722void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001723 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1724}
1725
1726void AudioPolicyService::UidPolicy::notifyService() {
1727 sp<AudioPolicyService> service = mService.promote();
1728 if (service != nullptr) {
1729 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001730 }
1731}
1732
Eric Laurente8c8b432018-10-17 10:08:02 -07001733void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1734 std::pair<bool, int>> *uids,
1735 uid_t uid,
1736 bool active,
1737 int state,
1738 bool insert) {
1739 if (isServiceUid(uid)) {
1740 return;
1741 }
1742 bool wasActive = isUidActive(uid);
1743 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001744 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001745 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001746 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001747 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001748 if (wasActive != isUidActive(uid) || state != previousState) {
1749 notifyService();
1750 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001751}
1752
Eric Laurente8c8b432018-10-17 10:08:02 -07001753void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1754 std::pair<bool, int>> *uids,
1755 uid_t uid,
1756 bool active,
1757 int state,
1758 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001759 auto it = uids->find(uid);
1760 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001761 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001762 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1763 it->second.first = active;
1764 }
1765 if (it->second.first) {
1766 it->second.second = state;
1767 } else {
1768 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1769 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001770 } else {
1771 uids->erase(it);
1772 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001773 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1774 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1775 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001776 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001777}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001778
Eric Laurent4eb58f12018-12-07 16:41:02 -08001779bool AudioPolicyService::UidPolicy::isA11yOnTop() {
Andy Hung79eacdb2023-11-30 19:34:24 -08001780 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001781 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001782 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001783 continue;
1784 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001785 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1786 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001787 return true;
1788 }
1789 }
1790 return false;
1791}
1792
Eric Laurentb78763e2018-10-17 10:08:02 -07001793bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1794{
1795 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1796 return it != mA11yUids.end();
1797}
1798
Oscar Azucena829d90d2022-01-28 17:17:56 -08001799void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1800 mAssistantUids.clear();
1801 mAssistantUids = uids;
1802}
1803
1804bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1805{
1806 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1807 return it != mAssistantUids.end();
1808}
1809
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001810void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1811 mActiveAssistantUids = activeUids;
1812}
1813
1814bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1815{
1816 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1817 mActiveAssistantUids.end(), uid);
1818 return it != mActiveAssistantUids.end();
1819}
1820
Oscar Azucena829d90d2022-01-28 17:17:56 -08001821void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1822 const size_t SIZE = 256;
1823 char buffer[SIZE];
1824 String8 result;
1825 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1826 snprintf(buffer, SIZE, "\t%s: \n", title);
1827 result.append(buffer);
1828 int counter = 0;
1829 if (uids.empty()) {
1830 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1831 result.append(buffer);
1832 return;
1833 }
1834 for (const auto &uid : uids) {
1835 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1836 result.append(buffer);
1837 }
1838 };
1839
1840 snprintf(buffer, SIZE, "UID Policy:\n");
1841 result.append(buffer);
1842 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1843 result.append(buffer);
1844
1845 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001846 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001847
1848 appendUidsToResult("Accessibility UIDs", mA11yUids);
1849
1850 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1851 result.append(buffer);
1852
1853 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1854 result.append(buffer);
1855
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001856 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001857}
1858
Michael Groovercfd28302018-12-11 19:16:46 -08001859// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1860void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1861 SensorPrivacyManager spm;
1862 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1863 spm.addSensorPrivacyListener(this);
1864}
1865
1866void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1867 SensorPrivacyManager spm;
1868 spm.removeSensorPrivacyListener(this);
1869}
1870
1871bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1872 return mSensorPrivacyEnabled;
1873}
1874
Evan Seversond8dc6832022-01-27 10:47:03 -08001875binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1876 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001877 mSensorPrivacyEnabled = enabled;
1878 sp<AudioPolicyService> service = mService.promote();
1879 if (service != nullptr) {
1880 service->updateUidStates();
1881 }
1882 return binder::Status::ok();
1883}
1884
Mathias Agopian65ab4712010-07-14 17:59:35 -07001885// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1886
Eric Laurentbfb1b832013-01-07 09:53:42 -08001887AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1888 const wp<AudioPolicyService>& service)
1889 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001890{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001891}
1892
1893
1894AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1895{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001896 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001897 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001898 }
1899 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001900}
1901
1902void AudioPolicyService::AudioCommandThread::onFirstRef()
1903{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001904 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001905}
1906
1907bool AudioPolicyService::AudioCommandThread::threadLoop()
1908{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001909 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001910
Andy Hung79eacdb2023-11-30 19:34:24 -08001911 audio_utils::unique_lock ul(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001912 while (!exitPending())
1913 {
Eric Laurent59a89232014-06-08 14:14:17 -07001914 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001915 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001916 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001917 nsecs_t curTime = systemTime();
1918 // commands are sorted by increasing time stamp: execute them from index 0 and up
1919 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001920 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001921 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001922 if (mAudioCommands.isEmpty()) {
1923 ++numTimesBecameEmpty;
1924 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001925 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001926
1927 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001928 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001929 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001930 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001931 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001932 ul.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001933 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1934 data->mVolume,
1935 data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001936 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001937 }break;
1938 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001939 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001940 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001941 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001942 ul.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001943 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hung79eacdb2023-11-30 19:34:24 -08001944 ul.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001945 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001946 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001947 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001948 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001949 data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001950 ul.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001951 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001952 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001953 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001954 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001955 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001956 ALOGV("AudioCommandThread() processing stop output portId %d",
1957 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001958 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001959 if (svc == 0) {
1960 break;
1961 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001962 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001963 svc->doStopOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001964 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001965 }break;
1966 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001967 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001968 ALOGV("AudioCommandThread() processing release output portId %d",
1969 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001970 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001971 if (svc == 0) {
1972 break;
1973 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001974 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001975 svc->doReleaseOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001976 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001977 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001978 case CREATE_AUDIO_PATCH: {
1979 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1980 ALOGV("AudioCommandThread() processing create audio patch");
1981 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1982 if (af == 0) {
1983 command->mStatus = PERMISSION_DENIED;
1984 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001985 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001986 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001987 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001988 }
1989 } break;
1990 case RELEASE_AUDIO_PATCH: {
1991 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1992 ALOGV("AudioCommandThread() processing release audio patch");
1993 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1994 if (af == 0) {
1995 command->mStatus = PERMISSION_DENIED;
1996 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001997 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001998 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001999 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002000 }
2001 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002002 case UPDATE_AUDIOPORT_LIST: {
2003 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002004 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002005 if (svc == 0) {
2006 break;
2007 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002008 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002009 svc->doOnAudioPortListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08002010 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002011 }break;
2012 case UPDATE_AUDIOPATCH_LIST: {
2013 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002014 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002015 if (svc == 0) {
2016 break;
2017 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002018 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002019 svc->doOnAudioPatchListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08002020 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002021 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002022 case CHANGED_AUDIOVOLUMEGROUP: {
2023 AudioVolumeGroupData *data =
2024 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2025 ALOGV("AudioCommandThread() processing update audio volume group");
2026 svc = mService.promote();
2027 if (svc == 0) {
2028 break;
2029 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002030 ul.unlock();
François Gaffiecfe17322018-11-07 13:41:29 +01002031 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
Andy Hung79eacdb2023-11-30 19:34:24 -08002032 ul.lock();
François Gaffiecfe17322018-11-07 13:41:29 +01002033 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002034 case SET_AUDIOPORT_CONFIG: {
2035 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2036 ALOGV("AudioCommandThread() processing set port config");
2037 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2038 if (af == 0) {
2039 command->mStatus = PERMISSION_DENIED;
2040 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002041 ul.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002042 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hung79eacdb2023-11-30 19:34:24 -08002043 ul.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002044 }
2045 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002046 case DYN_POLICY_MIX_STATE_UPDATE: {
2047 DynPolicyMixStateUpdateData *data =
2048 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002049 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002050 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002051 svc = mService.promote();
2052 if (svc == 0) {
2053 break;
2054 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002055 ul.unlock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002056 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
Andy Hung79eacdb2023-11-30 19:34:24 -08002057 ul.lock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002058 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002059 case RECORDING_CONFIGURATION_UPDATE: {
2060 RecordingConfigurationUpdateData *data =
2061 (RecordingConfigurationUpdateData *)command->mParam.get();
2062 ALOGV("AudioCommandThread() processing recording configuration update");
2063 svc = mService.promote();
2064 if (svc == 0) {
2065 break;
2066 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002067 ul.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002068 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002069 &data->mClientConfig, data->mClientEffects,
2070 &data->mDeviceConfig, data->mEffects,
2071 data->mPatchHandle, data->mSource);
Andy Hung79eacdb2023-11-30 19:34:24 -08002072 ul.lock();
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002073 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002074 case SET_EFFECT_SUSPENDED: {
2075 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2076 ALOGV("AudioCommandThread() processing set effect suspended");
2077 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2078 if (af != 0) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002079 ul.unlock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002080 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
Andy Hung79eacdb2023-11-30 19:34:24 -08002081 ul.lock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002082 }
2083 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002084 case AUDIO_MODULES_UPDATE: {
2085 ALOGV("AudioCommandThread() processing audio modules update");
2086 svc = mService.promote();
2087 if (svc == 0) {
2088 break;
2089 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002090 ul.unlock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002091 svc->doOnNewAudioModulesAvailable();
Andy Hung79eacdb2023-11-30 19:34:24 -08002092 ul.lock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002093 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002094 case ROUTING_UPDATED: {
2095 ALOGV("AudioCommandThread() processing routing update");
2096 svc = mService.promote();
2097 if (svc == 0) {
2098 break;
2099 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002100 ul.unlock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002101 svc->doOnRoutingUpdated();
Andy Hung79eacdb2023-11-30 19:34:24 -08002102 ul.lock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002103 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002104
Eric Laurented726cc2021-07-01 14:26:41 +02002105 case UPDATE_UID_STATES: {
2106 ALOGV("AudioCommandThread() processing updateUID states");
2107 svc = mService.promote();
2108 if (svc == 0) {
2109 break;
2110 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002111 ul.unlock();
Eric Laurented726cc2021-07-01 14:26:41 +02002112 svc->updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -08002113 ul.lock();
Eric Laurented726cc2021-07-01 14:26:41 +02002114 } break;
2115
Eric Laurent15903592022-02-24 20:44:36 +01002116 case CHECK_SPATIALIZER_OUTPUT: {
2117 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002118 svc = mService.promote();
2119 if (svc == 0) {
2120 break;
2121 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002122 ul.unlock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002123 svc->doOnCheckSpatializer();
Andy Hung79eacdb2023-11-30 19:34:24 -08002124 ul.lock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002125 } break;
2126
Eric Laurent15903592022-02-24 20:44:36 +01002127 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2128 ALOGV("AudioCommandThread() processing update spatializer tracks");
2129 svc = mService.promote();
2130 if (svc == 0) {
2131 break;
2132 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002133 ul.unlock();
Eric Laurent15903592022-02-24 20:44:36 +01002134 svc->doOnUpdateActiveSpatializerTracks();
Andy Hung79eacdb2023-11-30 19:34:24 -08002135 ul.lock();
Eric Laurent15903592022-02-24 20:44:36 +01002136 } break;
2137
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002138 case VOL_RANGE_INIT_REQUEST: {
2139 ALOGV("AudioCommandThread() processing volume range init request");
2140 svc = mService.promote();
2141 if (svc == 0) {
2142 break;
2143 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002144 ul.unlock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002145 svc->doOnVolumeRangeInitRequest();
Andy Hung79eacdb2023-11-30 19:34:24 -08002146 ul.lock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002147 } break;
2148
Mathias Agopian65ab4712010-07-14 17:59:35 -07002149 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002150 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002151 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002152 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002153 audio_utils::lock_guard _l(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002154 if (command->mWaitStatus) {
2155 command->mWaitStatus = false;
Andy Hung79eacdb2023-11-30 19:34:24 -08002156 command->mCond.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002157 }
2158 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002159 waitTime = -1;
Andy Hung79eacdb2023-11-30 19:34:24 -08002160 // release ul before releasing strong reference on the service as
Zach Janga754b4f2015-10-27 01:29:34 +00002161 // AudioPolicyService destructor calls AudioCommandThread::exit() which
Andy Hung79eacdb2023-11-30 19:34:24 -08002162 // acquires ul.
2163 ul.unlock();
Zach Janga754b4f2015-10-27 01:29:34 +00002164 svc.clear();
Andy Hung79eacdb2023-11-30 19:34:24 -08002165 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002166 } else {
2167 waitTime = mAudioCommands[0]->mTime - curTime;
2168 break;
2169 }
2170 }
Zach Janga754b4f2015-10-27 01:29:34 +00002171
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002172 // release delayed commands wake lock as many times as we made the queue is
2173 // empty during popping.
2174 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002175 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002176 }
2177
2178 // At this stage we have either an empty command queue or the first command in the queue
2179 // has a finite delay. So unless we are exiting it is safe to wait.
2180 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002181 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002182 if (waitTime == -1) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002183 mWaitWorkCV.wait(ul);
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002184 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002185 // discard return value.
2186 mWaitWorkCV.wait_for(ul, std::chrono::nanoseconds(waitTime));
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002187 }
Eric Laurent59a89232014-06-08 14:14:17 -07002188 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002189 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002190 // release delayed commands wake lock before quitting
2191 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002192 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002193 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002194 return false;
2195}
2196
2197status_t AudioPolicyService::AudioCommandThread::dump(int fd)
Andy Hung79eacdb2023-11-30 19:34:24 -08002198NO_THREAD_SAFETY_ANALYSIS // trylock
Mathias Agopian65ab4712010-07-14 17:59:35 -07002199{
2200 const size_t SIZE = 256;
2201 char buffer[SIZE];
2202 String8 result;
2203
Andy Hung79eacdb2023-11-30 19:34:24 -08002204 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002205 if (!locked) {
2206 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002207 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002208 }
2209
2210 snprintf(buffer, SIZE, "- Commands:\n");
2211 result = String8(buffer);
2212 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002213 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002214 mAudioCommands[i]->dump(buffer, SIZE);
2215 result.append(buffer);
2216 }
2217 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002218 if (mLastCommand != 0) {
2219 mLastCommand->dump(buffer, SIZE);
2220 result.append(buffer);
2221 } else {
2222 result.append(" none\n");
2223 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002224
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002225 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002226
Andy Hung79eacdb2023-11-30 19:34:24 -08002227 dumpReleaseLock(mMutex, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002228
2229 return NO_ERROR;
2230}
2231
Glenn Kastenfff6d712012-01-12 16:38:12 -08002232status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002233 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002234 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002235 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002236{
Eric Laurent0ede8922014-05-09 18:04:42 -07002237 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002238 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002239 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002240 data->mStream = stream;
2241 data->mVolume = volume;
2242 data->mIO = output;
2243 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002244 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002245 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002246 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002247 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002248}
2249
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002250status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002251 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002252 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002253{
Eric Laurent0ede8922014-05-09 18:04:42 -07002254 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002255 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002256 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002257 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002258 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002259 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002260 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002261 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002262 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002263 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002264}
2265
2266status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2267{
Eric Laurent0ede8922014-05-09 18:04:42 -07002268 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002269 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002270 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002271 data->mVolume = volume;
2272 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002273 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002274 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002275 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002276}
2277
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002278void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2279 audio_session_t sessionId,
2280 bool suspended)
2281{
2282 sp<AudioCommand> command = new AudioCommand();
2283 command->mCommand = SET_EFFECT_SUSPENDED;
2284 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2285 data->mEffectId = effectId;
2286 data->mSessionId = sessionId;
2287 data->mSuspended = suspended;
2288 command->mParam = data;
2289 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2290 effectId, sessionId, suspended);
2291 sendCommand(command);
2292}
2293
2294
Eric Laurentd7fe0862018-07-14 16:48:01 -07002295void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002296{
Eric Laurent0ede8922014-05-09 18:04:42 -07002297 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002298 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002299 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002300 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002301 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002302 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002303 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002304}
2305
Eric Laurentd7fe0862018-07-14 16:48:01 -07002306void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002307{
Eric Laurent0ede8922014-05-09 18:04:42 -07002308 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002309 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002310 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002311 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002312 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002313 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002314 sendCommand(command);
2315}
2316
Eric Laurent951f4552014-05-20 10:48:17 -07002317status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2318 const struct audio_patch *patch,
2319 audio_patch_handle_t *handle,
2320 int delayMs)
2321{
2322 status_t status = NO_ERROR;
2323
2324 sp<AudioCommand> command = new AudioCommand();
2325 command->mCommand = CREATE_AUDIO_PATCH;
2326 CreateAudioPatchData *data = new CreateAudioPatchData();
2327 data->mPatch = *patch;
2328 data->mHandle = *handle;
2329 command->mParam = data;
2330 command->mWaitStatus = true;
2331 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2332 status = sendCommand(command, delayMs);
2333 if (status == NO_ERROR) {
2334 *handle = data->mHandle;
2335 }
2336 return status;
2337}
2338
2339status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2340 int delayMs)
2341{
2342 sp<AudioCommand> command = new AudioCommand();
2343 command->mCommand = RELEASE_AUDIO_PATCH;
2344 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2345 data->mHandle = handle;
2346 command->mParam = data;
2347 command->mWaitStatus = true;
2348 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2349 return sendCommand(command, delayMs);
2350}
2351
Eric Laurentb52c1522014-05-20 11:27:36 -07002352void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2353{
2354 sp<AudioCommand> command = new AudioCommand();
2355 command->mCommand = UPDATE_AUDIOPORT_LIST;
2356 ALOGV("AudioCommandThread() adding update audio port list");
2357 sendCommand(command);
2358}
2359
Eric Laurented726cc2021-07-01 14:26:41 +02002360void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2361{
2362 sp<AudioCommand> command = new AudioCommand();
2363 command->mCommand = UPDATE_UID_STATES;
2364 ALOGV("AudioCommandThread() adding update UID states");
2365 sendCommand(command);
2366}
2367
Eric Laurentb52c1522014-05-20 11:27:36 -07002368void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2369{
2370 sp<AudioCommand>command = new AudioCommand();
2371 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2372 ALOGV("AudioCommandThread() adding update audio patch list");
2373 sendCommand(command);
2374}
2375
François Gaffiecfe17322018-11-07 13:41:29 +01002376void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2377 int flags)
2378{
2379 sp<AudioCommand>command = new AudioCommand();
2380 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2381 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2382 data->mGroup = group;
2383 data->mFlags = flags;
2384 command->mParam = data;
2385 ALOGV("AudioCommandThread() adding audio volume group changed");
2386 sendCommand(command);
2387}
2388
Eric Laurente1715a42014-05-20 11:30:42 -07002389status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2390 const struct audio_port_config *config, int delayMs)
2391{
2392 sp<AudioCommand> command = new AudioCommand();
2393 command->mCommand = SET_AUDIOPORT_CONFIG;
2394 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2395 data->mConfig = *config;
2396 command->mParam = data;
2397 command->mWaitStatus = true;
2398 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2399 return sendCommand(command, delayMs);
2400}
2401
Jean-Michel Trivide801052015-04-14 19:10:14 -07002402void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002403 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002404{
2405 sp<AudioCommand> command = new AudioCommand();
2406 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2407 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2408 data->mRegId = regId;
2409 data->mState = state;
2410 command->mParam = data;
2411 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002412 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002413 sendCommand(command);
2414}
2415
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002416void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002417 int event,
2418 const record_client_info_t *clientInfo,
2419 const audio_config_base_t *clientConfig,
2420 std::vector<effect_descriptor_t> clientEffects,
2421 const audio_config_base_t *deviceConfig,
2422 std::vector<effect_descriptor_t> effects,
2423 audio_patch_handle_t patchHandle,
2424 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002425{
2426 sp<AudioCommand>command = new AudioCommand();
2427 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2428 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2429 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002430 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002431 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002432 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002433 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002434 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002435 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002436 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002437 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002438 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2439 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002440 sendCommand(command);
2441}
2442
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002443void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2444{
2445 sp<AudioCommand> command = new AudioCommand();
2446 command->mCommand = AUDIO_MODULES_UPDATE;
2447 sendCommand(command);
2448}
2449
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002450void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2451{
2452 sp<AudioCommand>command = new AudioCommand();
2453 command->mCommand = ROUTING_UPDATED;
2454 ALOGV("AudioCommandThread() adding routing update");
2455 sendCommand(command);
2456}
2457
Eric Laurent81dd0f52021-07-05 11:54:40 +02002458void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2459{
2460 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002461 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002462 ALOGV("AudioCommandThread() adding check spatializer");
2463 sendCommand(command);
2464}
2465
Eric Laurent15903592022-02-24 20:44:36 +01002466void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2467{
2468 sp<AudioCommand>command = new AudioCommand();
2469 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2470 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2471 sendCommand(command);
2472}
2473
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002474void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2475{
2476 sp<AudioCommand>command = new AudioCommand();
2477 command->mCommand = VOL_RANGE_INIT_REQUEST;
2478 ALOGV("AudioCommandThread() adding volume range init request");
2479 sendCommand(command);
2480}
2481
Eric Laurent0ede8922014-05-09 18:04:42 -07002482status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2483{
2484 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002485 audio_utils::lock_guard _l(mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002486 insertCommand_l(command, delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002487 mWaitWorkCV.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002488 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002489 audio_utils::unique_lock ul(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002490 while (command->mWaitStatus) {
2491 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002492 if (command->mCond.wait_for(
Andy Hung02ea2a02024-01-25 17:02:30 -08002493 ul, std::chrono::nanoseconds(timeOutNs), getTid()) == std::cv_status::timeout) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002494 command->mStatus = TIMED_OUT;
2495 command->mWaitStatus = false;
2496 }
2497 }
2498 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002499}
2500
Andy Hung79eacdb2023-11-30 19:34:24 -08002501// insertCommand_l() must be called with mMutex held
Eric Laurent0ede8922014-05-09 18:04:42 -07002502void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002503{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002504 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002505 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002506 command->mTime = systemTime() + milliseconds(delayMs);
2507
2508 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002509 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002510 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002511 }
2512
2513 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002514 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002515 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002516 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2517 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002518
2519 // create audio patch or release audio patch commands are equivalent
2520 // with regard to filtering
2521 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2522 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2523 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2524 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2525 continue;
2526 }
2527 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002528
2529 switch (command->mCommand) {
2530 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002531 ParametersData *data = (ParametersData *)command->mParam.get();
2532 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002533 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002534 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002535 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002536 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2537 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2538 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002539 String8 key;
2540 String8 value;
2541 param.getAt(j, key, value);
2542 for (size_t k = 0; k < param2.size(); k++) {
2543 String8 key2;
2544 String8 value2;
2545 param2.getAt(k, key2, value2);
2546 if (key2 == key) {
2547 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002548 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002549 break;
2550 }
2551 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002552 }
2553 // if all keys have been filtered out, remove the command.
2554 // otherwise, update the key value pairs
2555 if (param2.size() == 0) {
2556 removedCommands.add(command2);
2557 } else {
2558 data2->mKeyValuePairs = param2.toString();
2559 }
Eric Laurent21e54562013-09-23 12:08:05 -07002560 command->mTime = command2->mTime;
2561 // force delayMs to non 0 so that code below does not request to wait for
2562 // command status as the command is now delayed
2563 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002564 } break;
2565
2566 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002567 VolumeData *data = (VolumeData *)command->mParam.get();
2568 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002569 if (data->mIO != data2->mIO) break;
2570 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002571 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002572 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002573 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002574 command->mTime = command2->mTime;
2575 // force delayMs to non 0 so that code below does not request to wait for
2576 // command status as the command is now delayed
2577 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002578 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002579
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002580 case SET_VOICE_VOLUME: {
2581 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2582 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2583 ALOGV("Filtering out voice volume command value %f replaced by %f",
2584 data2->mVolume, data->mVolume);
2585 removedCommands.add(command2);
2586 command->mTime = command2->mTime;
2587 // force delayMs to non 0 so that code below does not request to wait for
2588 // command status as the command is now delayed
2589 delayMs = 1;
2590 } break;
2591
Eric Laurente45b48a2014-09-04 16:40:57 -07002592 case CREATE_AUDIO_PATCH:
2593 case RELEASE_AUDIO_PATCH: {
2594 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002595 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002596 if (command->mCommand == CREATE_AUDIO_PATCH) {
2597 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002598 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002599 } else {
2600 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002601 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002602 }
2603 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002604 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002605 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2606 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002607 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002608 } else {
2609 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002610 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002611 }
2612 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002613 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2614 same output. */
2615 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2616 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2617 bool isOutputDiff = false;
2618 if (patch.num_sources == patch2.num_sources) {
2619 for (unsigned count = 0; count < patch.num_sources; count++) {
2620 if (patch.sources[count].id != patch2.sources[count].id) {
2621 isOutputDiff = true;
2622 break;
2623 }
2624 }
2625 if (isOutputDiff)
2626 break;
2627 }
2628 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002629 ALOGV("Filtering out %s audio patch command for handle %d",
2630 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2631 removedCommands.add(command2);
2632 command->mTime = command2->mTime;
2633 // force delayMs to non 0 so that code below does not request to wait for
2634 // command status as the command is now delayed
2635 delayMs = 1;
2636 } break;
2637
Jean-Michel Trivide801052015-04-14 19:10:14 -07002638 case DYN_POLICY_MIX_STATE_UPDATE: {
2639
2640 } break;
2641
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002642 case RECORDING_CONFIGURATION_UPDATE: {
2643
2644 } break;
2645
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002646 case ROUTING_UPDATED: {
2647
2648 } break;
2649
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002650 case VOL_RANGE_INIT_REQUEST: {
2651 // command may come from different requests, do not filter
2652 } break;
2653
Mathias Agopian65ab4712010-07-14 17:59:35 -07002654 default:
2655 break;
2656 }
2657 }
2658
2659 // remove filtered commands
2660 for (size_t j = 0; j < removedCommands.size(); j++) {
2661 // removed commands always have time stamps greater than current command
2662 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002663 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002664 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002665 mAudioCommands.removeAt(k);
2666 break;
2667 }
2668 }
2669 }
2670 removedCommands.clear();
2671
Eric Laurentaa79bef2015-01-15 14:33:51 -08002672 // Disable wait for status if delay is not 0.
2673 // Except for create audio patch command because the returned patch handle
2674 // is needed by audio policy manager
2675 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002676 command->mWaitStatus = false;
2677 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002678
Mathias Agopian65ab4712010-07-14 17:59:35 -07002679 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002680 ALOGV("inserting command: %d at index %zd, num commands %zu",
2681 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002682 mAudioCommands.insertAt(command, i + 1);
2683}
2684
2685void AudioPolicyService::AudioCommandThread::exit()
2686{
Steve Block3856b092011-10-20 11:56:00 +01002687 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002688 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002689 audio_utils::lock_guard _l(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002690 requestExit();
Andy Hung79eacdb2023-11-30 19:34:24 -08002691 mWaitWorkCV.notify_one();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002692 }
Zach Janga754b4f2015-10-27 01:29:34 +00002693 // Note that we can call it from the thread loop if all other references have been released
2694 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002695 requestExitAndWait();
2696}
2697
2698void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2699{
2700 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2701 mCommand,
2702 (int)ns2s(mTime),
2703 (int)ns2ms(mTime)%1000,
2704 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002705 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002706}
2707
Dima Zavinfce7a472011-04-19 22:30:36 -07002708/******* helpers for the service_ops callbacks defined below *********/
2709void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2710 const char *keyValuePairs,
2711 int delayMs)
2712{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002713 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002714 delayMs);
2715}
2716
2717int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2718 float volume,
2719 audio_io_handle_t output,
2720 int delayMs)
2721{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002722 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002723 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002724}
2725
Dima Zavinfce7a472011-04-19 22:30:36 -07002726int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2727{
2728 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2729}
2730
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002731void AudioPolicyService::setEffectSuspended(int effectId,
2732 audio_session_t sessionId,
2733 bool suspended)
2734{
2735 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2736}
2737
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002738Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002739{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002740 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002741 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002742}
2743
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002744
Dima Zavinfce7a472011-04-19 22:30:36 -07002745extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002746audio_module_handle_t aps_load_hw_module(void *service __unused,
2747 const char *name);
2748audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002749 audio_devices_t *pDevices,
2750 uint32_t *pSamplingRate,
2751 audio_format_t *pFormat,
2752 audio_channel_mask_t *pChannelMask,
2753 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002754 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002755
Eric Laurent2d388ec2014-03-07 13:25:54 -08002756audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002757 audio_module_handle_t module,
2758 audio_devices_t *pDevices,
2759 uint32_t *pSamplingRate,
2760 audio_format_t *pFormat,
2761 audio_channel_mask_t *pChannelMask,
2762 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002763 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002764 const audio_offload_info_t *offloadInfo);
2765audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002766 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002767 audio_io_handle_t output2);
2768int aps_close_output(void *service __unused, audio_io_handle_t output);
2769int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2770int aps_restore_output(void *service __unused, audio_io_handle_t output);
2771audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002772 audio_devices_t *pDevices,
2773 uint32_t *pSamplingRate,
2774 audio_format_t *pFormat,
2775 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002776 audio_in_acoustics_t acoustics __unused);
2777audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002778 audio_module_handle_t module,
2779 audio_devices_t *pDevices,
2780 uint32_t *pSamplingRate,
2781 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002782 audio_channel_mask_t *pChannelMask);
2783int aps_close_input(void *service __unused, audio_io_handle_t input);
2784int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002785int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002786 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002787 audio_io_handle_t dst_output);
2788char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2789 const char *keys);
2790void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2791 const char *kv_pairs, int delay_ms);
2792int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002793 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002794 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002795int aps_set_voice_volume(void *service, float volume, int delay_ms);
2796};
Dima Zavinfce7a472011-04-19 22:30:36 -07002797
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002798} // namespace android