blob: aed6458086e78092dc468bff54da98bb57c75284 [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) \
Andy Hungc747c532022-03-07 21:41:14 -0800169
170// singleton for Binder Method Statistics for IAudioPolicyService
171static auto& getIAudioPolicyServiceStatistics() {
172 using Code = int;
173
174#pragma push_macro("BINDER_METHOD_ENTRY")
175#undef BINDER_METHOD_ENTRY
176#define BINDER_METHOD_ENTRY(ENTRY) \
177 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
178
179 static mediautils::MethodStatistics<Code> methodStatistics{
180 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
181 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
182 };
183#pragma pop_macro("BINDER_METHOD_ENTRY")
184
185 return methodStatistics;
186}
187
Mathias Agopian65ab4712010-07-14 17:59:35 -0700188// ----------------------------------------------------------------------------
189
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530190static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
191{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700192 AudioPolicyManager *apm = nullptr;
193 media::AudioPolicyConfig apmConfig;
194 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
195 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
196 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
197 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
198 "Only default engine is currently supported with the AIDL HAL");
199 apm = new AudioPolicyManager(config,
200 loadApmEngineLibraryAndCreateEngine(
201 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
202 clientInterface);
203 } else {
204 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
205 apm = new AudioPolicyManager(config,
206 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
207 clientInterface);
208 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530209 status_t status = apm->initialize();
210 if (status != NO_ERROR) {
211 delete apm;
212 apm = nullptr;
213 }
214 return apm;
215}
216
217static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
218{
219 delete interface;
220}
221// ----------------------------------------------------------------------------
222
Mathias Agopian65ab4712010-07-14 17:59:35 -0700223AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700224 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700225 mAudioPolicyManager(NULL),
226 mAudioPolicyClient(NULL),
227 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530228 mCaptureStateNotifier(false),
229 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100230 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
231 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800232 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530233}
234
235void AudioPolicyService::loadAudioPolicyManager()
236{
237 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
238 if (mLibraryHandle != nullptr) {
239 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
240 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
241 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
242 const char *lastError = dlerror();
243 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
244 __func__, lastError != nullptr ? lastError : "no error");
245
246 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
247 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
248 lastError = dlerror();
249 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
250 __func__, lastError != nullptr ? lastError : "no error");
251 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
252 unloadAudioPolicyManager();
253 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
254 }
255 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700256}
257
258void AudioPolicyService::onFirstRef()
259{
Andy Hungd47aca22022-03-15 11:50:51 -0700260 // Log an AudioPolicy "constructor" mediametrics event on first ref.
261 // This records the time it takes to load the audio modules and devices.
262 mediametrics::Defer defer([beginNs = systemTime()] {
263 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
264 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
265 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
266 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700267 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800268 audio_utils::lock_guard _l(mMutex);
Eric Laurent93575202011-01-18 18:39:02 -0800269
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700270 // start audio commands thread
271 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
272 // start output activity command thread
273 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700274
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700275 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530276
277 loadAudioPolicyManager();
278 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700279 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200280
bryant_liuba2b4392014-06-11 16:49:30 +0800281 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000282 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
Andy Hungd3595ed2023-12-19 15:34:46 -0800283 auto audioPolicyEffects = sp<AudioPolicyEffects>::make(effectsFactoryHal);
284 auto uidPolicy = sp<UidPolicy>::make(this);
285 auto sensorPrivacyPolicy = sp<SensorPrivacyPolicy>::make(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700286 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800287 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700288 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000289 mUidPolicy = uidPolicy;
290 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700291 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000292 uidPolicy->registerSelf();
293 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200294
Eric Laurent81dd0f52021-07-05 11:54:40 +0200295 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200296 if (mAudioPolicyManager != nullptr) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800297 audio_utils::lock_guard _l(mMutex);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200298 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
299 AudioDeviceTypeAddrVector devices;
300 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
301 if (hasSpatializer) {
Andy Hung1040da52023-12-06 20:59:06 -0800302 // Unlock as Spatializer::create() will use the callback and acquire the
303 // AudioPolicyService_Mutex.
Andy Hung79eacdb2023-11-30 19:34:24 -0800304 mMutex.unlock();
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000305 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Andy Hung79eacdb2023-11-30 19:34:24 -0800306 mMutex.lock();
Eric Laurent52b0bd52021-09-27 15:25:40 +0200307 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700308 if (mSpatializer == nullptr) {
309 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
310 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
311 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
312 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200313 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200314 AudioSystem::audioPolicyReady();
François Gaffie163ce832023-06-28 11:36:35 +0200315 // AudioFlinger will handle effect creation and register these effects on audio_policy
316 // service. Hence, audio_policy service must be ready.
317 audioPolicyEffects->setDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700318}
319
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530320void AudioPolicyService::unloadAudioPolicyManager()
321{
322 ALOGV("%s ", __func__);
323 if (mLibraryHandle != nullptr) {
324 dlclose(mLibraryHandle);
325 }
326 mLibraryHandle = nullptr;
327 mCreateAudioPolicyManager = nullptr;
328 mDestroyAudioPolicyManager = nullptr;
329}
330
Mathias Agopian65ab4712010-07-14 17:59:35 -0700331AudioPolicyService::~AudioPolicyService()
332{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700333 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700334 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700335
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530336 mDestroyAudioPolicyManager(mAudioPolicyManager);
337 unloadAudioPolicyManager();
338
Eric Laurentdce54a12014-03-10 12:19:46 -0700339 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700340
341 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800342 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800343
344 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800345 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000346
347 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800348 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700349}
350
351// A notification client is always registered by AudioSystem when the client process
352// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800353Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700354{
Eric Laurent12590252015-08-21 18:40:20 -0700355 if (client == 0) {
356 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800357 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700358 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800359 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700360
361 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800362 pid_t pid = IPCThreadState::self()->getCallingPid();
363 int64_t token = ((int64_t)uid<<32) | pid;
364
365 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700366 sp<NotificationClient> notificationClient = new NotificationClient(this,
367 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800368 uid,
369 pid);
370 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700371
luochaojiang908c7d72018-06-21 14:58:04 +0800372 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700373
Marco Nelissenf8880202014-11-14 07:58:25 -0800374 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700375 binder->linkToDeath(notificationClient);
376 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800377 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700378}
379
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800380Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700381{
Andy Hung79eacdb2023-11-30 19:34:24 -0800382 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurente8726fe2015-06-26 09:39:24 -0700383
384 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800385 pid_t pid = IPCThreadState::self()->getCallingPid();
386 int64_t token = ((int64_t)uid<<32) | pid;
387
388 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800389 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700390 }
luochaojiang908c7d72018-06-21 14:58:04 +0800391 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800392 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700393}
394
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800395Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100396{
Andy Hung79eacdb2023-11-30 19:34:24 -0800397 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100398
399 uid_t uid = IPCThreadState::self()->getCallingUid();
400 pid_t pid = IPCThreadState::self()->getCallingPid();
401 int64_t token = ((int64_t)uid<<32) | pid;
402
403 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800404 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100405 }
406 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800407 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100408}
409
Eric Laurentb52c1522014-05-20 11:27:36 -0700410// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800411void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700412{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000413 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800414 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800415 audio_utils::lock_guard _l(mNotificationClientsMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800416 int64_t token = ((int64_t)uid<<32) | pid;
417 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800418 for (size_t i = 0; i < mNotificationClients.size(); i++) {
419 if (mNotificationClients.valueAt(i)->uid() == uid) {
420 hasSameUid = true;
421 break;
422 }
423 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000424 }
425 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800426 audio_utils::lock_guard _l(mMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800427 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700428 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700429 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700430 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800431 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700432}
433
434void AudioPolicyService::onAudioPortListUpdate()
435{
436 mOutputCommandThread->updateAudioPortListCommand();
437}
438
439void AudioPolicyService::doOnAudioPortListUpdate()
440{
Andy Hung79eacdb2023-11-30 19:34:24 -0800441 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700442 for (size_t i = 0; i < mNotificationClients.size(); i++) {
443 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
444 }
445}
446
447void AudioPolicyService::onAudioPatchListUpdate()
448{
449 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700450}
451
Eric Laurentb52c1522014-05-20 11:27:36 -0700452void AudioPolicyService::doOnAudioPatchListUpdate()
453{
Andy Hung79eacdb2023-11-30 19:34:24 -0800454 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700455 for (size_t i = 0; i < mNotificationClients.size(); i++) {
456 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
457 }
458}
459
François Gaffiecfe17322018-11-07 13:41:29 +0100460void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
461{
462 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
463}
464
465void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
466{
Andy Hung79eacdb2023-11-30 19:34:24 -0800467 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100468 for (size_t i = 0; i < mNotificationClients.size(); i++) {
469 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
470 }
471}
472
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700473void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700474{
475 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000476 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700477 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
478}
479
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700480void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700481{
Andy Hung79eacdb2023-11-30 19:34:24 -0800482 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700483 for (size_t i = 0; i < mNotificationClients.size(); i++) {
484 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
485 }
486}
487
Eric Laurenta9f86652018-11-28 17:23:11 -0800488void AudioPolicyService::onRecordingConfigurationUpdate(
489 int event,
490 const record_client_info_t *clientInfo,
491 const audio_config_base_t *clientConfig,
492 std::vector<effect_descriptor_t> clientEffects,
493 const audio_config_base_t *deviceConfig,
494 std::vector<effect_descriptor_t> effects,
495 audio_patch_handle_t patchHandle,
496 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800497{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800498 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800499 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800500}
501
Eric Laurenta9f86652018-11-28 17:23:11 -0800502void AudioPolicyService::doOnRecordingConfigurationUpdate(
503 int event,
504 const record_client_info_t *clientInfo,
505 const audio_config_base_t *clientConfig,
506 std::vector<effect_descriptor_t> clientEffects,
507 const audio_config_base_t *deviceConfig,
508 std::vector<effect_descriptor_t> effects,
509 audio_patch_handle_t patchHandle,
510 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800511{
Andy Hung79eacdb2023-11-30 19:34:24 -0800512 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800513 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800514 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800515 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800516 }
517}
518
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700519void AudioPolicyService::onRoutingUpdated()
520{
521 mOutputCommandThread->routingChangedCommand();
522}
523
524void AudioPolicyService::doOnRoutingUpdated()
525{
Andy Hung79eacdb2023-11-30 19:34:24 -0800526 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700527 for (size_t i = 0; i < mNotificationClients.size(); i++) {
528 mNotificationClients.valueAt(i)->onRoutingUpdated();
529 }
530}
531
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000532void AudioPolicyService::onVolumeRangeInitRequest()
533{
534 mOutputCommandThread->volRangeInitReqCommand();
535}
536
537void AudioPolicyService::doOnVolumeRangeInitRequest()
538{
Andy Hung79eacdb2023-11-30 19:34:24 -0800539 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000540 for (size_t i = 0; i < mNotificationClients.size(); i++) {
541 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
542 }
543}
544
Eric Laurent81dd0f52021-07-05 11:54:40 +0200545void AudioPolicyService::onCheckSpatializer()
546{
Andy Hung79eacdb2023-11-30 19:34:24 -0800547 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200548 onCheckSpatializer_l();
549}
550
551void AudioPolicyService::onCheckSpatializer_l()
552{
553 if (mSpatializer != nullptr) {
554 mOutputCommandThread->checkSpatializerCommand();
555 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200556}
557
558void AudioPolicyService::doOnCheckSpatializer()
559{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200560 ALOGV("%s mSpatializer %p level %d",
561 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200562
Eric Laurent39095982021-08-24 18:29:27 +0200563 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200564 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000565 if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200566 audio_io_handle_t currentOutput = mSpatializer->getOutput();
567 audio_io_handle_t newOutput;
568 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
569 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200570
Andy Hung79eacdb2023-11-30 19:34:24 -0800571 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200572 status_t status =
573 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100574 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
575 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200576 if (status == NO_ERROR && currentOutput == newOutput) {
577 return;
578 }
Eric Laurent15903592022-02-24 20:44:36 +0100579 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Andy Hung79eacdb2023-11-30 19:34:24 -0800580 mMutex.unlock();
Eric Laurent39095982021-08-24 18:29:27 +0200581 // It is OK to call detachOutput() is none is already attached.
582 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200583 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
584 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200585 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800586 mMutex.lock();
Eric Laurent39095982021-08-24 18:29:27 +0200587 if (status != NO_ERROR) {
588 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
589 }
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000590 } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
591 mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200592 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200593
Eric Laurent39095982021-08-24 18:29:27 +0200594 if (output != AUDIO_IO_HANDLE_NONE) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800595 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200596 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200597 }
598 }
599 }
600}
601
Eric Laurent11094172022-04-05 18:27:42 +0200602size_t AudioPolicyService::countActiveClientsOnOutput_l(
603 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100604 size_t count = 0;
605 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
606 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200607 if (client->io == output && client->active
608 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100609 count++;
610 }
611 }
612 return count;
613}
614
615void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
616 if (mSpatializer == nullptr) {
617 return;
618 }
619 mOutputCommandThread->updateActiveSpatializerTracksCommand();
620}
621
622void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
623{
Eric Laurent21270b62022-07-04 15:11:29 +0200624 if (mSpatializer == nullptr) {
625 return;
626 }
627 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200628 size_t activeClients;
629 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800630 audio_utils::lock_guard _l(mMutex);
Eric Laurent21270b62022-07-04 15:11:29 +0200631 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100632 }
Eric Laurent21270b62022-07-04 15:11:29 +0200633 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100634}
635
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800636status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
637 audio_patch_handle_t *handle,
638 int delayMs)
639{
640 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
641}
642
643status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
644 int delayMs)
645{
646 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
647}
648
Eric Laurente1715a42014-05-20 11:30:42 -0700649status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
650 int delayMs)
651{
652 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
653}
654
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800655AudioPolicyService::NotificationClient::NotificationClient(
656 const sp<AudioPolicyService>& service,
657 const sp<media::IAudioPolicyServiceClient>& client,
658 uid_t uid,
659 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800660 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100661 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700662{
663}
664
665AudioPolicyService::NotificationClient::~NotificationClient()
666{
667}
668
669void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
670{
671 sp<NotificationClient> keep(this);
672 sp<AudioPolicyService> service = mService.promote();
673 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800674 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700675 }
676}
677
678void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
679{
Eric Laurente8726fe2015-06-26 09:39:24 -0700680 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700681 mAudioPolicyServiceClient->onAudioPortListUpdate();
682 }
683}
684
685void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
686{
Eric Laurente8726fe2015-06-26 09:39:24 -0700687 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700688 mAudioPolicyServiceClient->onAudioPatchListUpdate();
689 }
690}
Eric Laurent57dae992011-07-24 13:36:09 -0700691
Pattydd807582021-11-04 21:01:03 +0800692void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100693 int flags)
694{
695 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
696 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
697 }
698}
699
700
Jean-Michel Trivide801052015-04-14 19:10:14 -0700701void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700702 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700703{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700704 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800705 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
706 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800707 }
708}
709
710void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800711 int event,
712 const record_client_info_t *clientInfo,
713 const audio_config_base_t *clientConfig,
714 std::vector<effect_descriptor_t> clientEffects,
715 const audio_config_base_t *deviceConfig,
716 std::vector<effect_descriptor_t> effects,
717 audio_patch_handle_t patchHandle,
718 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800719{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700720 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800721 status_t status = [&]() -> status_t {
722 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
723 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
724 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700725 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700726 legacy2aidl_audio_config_base_t_AudioConfigBase(
727 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800728 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
729 convertContainer<std::vector<media::EffectDescriptor>>(
730 clientEffects,
731 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700732 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700733 legacy2aidl_audio_config_base_t_AudioConfigBase(
734 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800735 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
736 convertContainer<std::vector<media::EffectDescriptor>>(
737 effects,
738 legacy2aidl_effect_descriptor_t_EffectDescriptor));
739 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
740 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700741 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
742 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800743 return aidl_utils::statusTFromBinderStatus(
744 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
745 clientInfoAidl,
746 clientConfigAidl,
747 clientEffectsAidl,
748 deviceConfigAidl,
749 effectsAidl,
750 patchHandleAidl,
751 sourceAidl));
752 }();
753 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700754 }
755}
756
Eric Laurente8726fe2015-06-26 09:39:24 -0700757void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
758{
759 mAudioPortCallbacksEnabled = enabled;
760}
761
François Gaffiecfe17322018-11-07 13:41:29 +0100762void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
763{
764 mAudioVolumeGroupCallbacksEnabled = enabled;
765}
Eric Laurente8726fe2015-06-26 09:39:24 -0700766
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700767void AudioPolicyService::NotificationClient::onRoutingUpdated()
768{
769 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
770 mAudioPolicyServiceClient->onRoutingUpdated();
771 }
772}
773
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000774void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
775{
776 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
777 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
778 }
779}
780
Mathias Agopian65ab4712010-07-14 17:59:35 -0700781void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700782 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700783 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700784}
785
Andy Hung79eacdb2023-11-30 19:34:24 -0800786static void dumpReleaseLock(audio_utils::mutex& mutex, bool locked)
787 RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000788{
789 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700790}
791
792status_t AudioPolicyService::dumpInternals(int fd)
793{
794 const size_t SIZE = 256;
795 char buffer[SIZE];
796 String8 result;
797
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000798 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800799 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000800 std::stringstream msg;
801 size_t i = 0;
802 for (auto usage : mSupportedSystemUsages) {
803 if (i++ != 0) msg << ", ";
804 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
805 msg << strUsage;
806 } else {
807 msg << usage << " (unknown)";
808 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800809 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000810 if (i == 0) {
811 msg << "None";
812 }
813 msg << std::endl;
814 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800815
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000816 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800817
818 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700819 return NO_ERROR;
820}
821
Eric Laurente8c8b432018-10-17 10:08:02 -0700822void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800823{
Andy Hung79eacdb2023-11-30 19:34:24 -0800824 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700825 updateUidStates_l();
826}
827
828void AudioPolicyService::updateUidStates_l()
829{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800830// Go over all active clients and allow capture (does not force silence) in the
831// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800832// The client is in the active assistant list
833// AND is TOP
834// AND an accessibility service is TOP
835// AND source is either VOICE_RECOGNITION OR HOTWORD
836// OR there is no active privacy sensitive capture or call
837// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
838// AND source is VOICE_RECOGNITION OR HOTWORD
839// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800840// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700841// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800842// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800843// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800844// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
845// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800846// OR The client is an accessibility service
847// AND Is on TOP
848// AND the source is VOICE_RECOGNITION or HOTWORD
849// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700850// AND there is no active privacy sensitive capture or call
851// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800852// AND is on TOP
853// AND the source is VOICE_RECOGNITION or HOTWORD
854// OR the client source is virtual (remote submix, call audio TX or RX...)
855// OR the client source is HOTWORD
856// AND is on TOP
857// OR all active clients are using HOTWORD source
858// AND no call is active
859// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
860// OR the client is the current InputMethodService
861// AND a RTT call is active AND the source is VOICE_RECOGNITION
862// OR Any client
863// AND The assistant is not on TOP
864// AND is on TOP or latest started
865// AND there is no active privacy sensitive capture or call
866// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800867
Eric Laurent4e947da2019-10-17 15:24:06 -0700868
Eric Laurent4eb58f12018-12-07 16:41:02 -0800869 sp<AudioRecordClient> topActive;
870 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800871 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700872 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800873 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700874
Eric Laurenta46bedb2018-12-07 18:01:26 -0800875 nsecs_t topStartNs = 0;
876 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800877 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800878 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800879 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800880 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
881 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800882 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800883 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700884 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800885 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
886 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700887 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700888 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700889 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800890
Michael Groovercfd28302018-12-11 19:16:46 -0800891 // if Sensor Privacy is enabled then all recordings should be silenced.
892 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
893 silenceAllRecordings_l();
894 return;
895 }
896
Eric Laurente8c8b432018-10-17 10:08:02 -0700897 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
898 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000899 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
900 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800901 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700902 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800903 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700904
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700905 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700906 // clients which app is in IDLE state are not eligible for top active or
907 // latest active
908 if (appState == APP_STATE_IDLE) {
909 continue;
910 }
911
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700912 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700913 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800914 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700915 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700916 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800917 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800918 bool isPrivacySensitive =
919 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700920
Eric Laurentc21d5692020-02-25 10:24:36 -0800921 if (appState == APP_STATE_TOP) {
922 if (isPrivacySensitive) {
923 if (current->startTimeNs > topSensitiveStartNs) {
924 topSensitiveActive = current;
925 topSensitiveStartNs = current->startTimeNs;
926 }
927 } else {
928 if (current->startTimeNs > topStartNs) {
929 topActive = current;
930 topStartNs = current->startTimeNs;
931 }
932 }
933 if (isAssistant) {
934 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800935 if (isActiveAssistant) {
936 useActiveAssistantList = true;
937 } else if (!useActiveAssistantList) {
938 if (current->startTimeNs > latestAssistantStartNs) {
939 latestActiveAssistant = current;
940 latestAssistantStartNs = current->startTimeNs;
941 }
942 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800943 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800944 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800945 // Clients capturing for HOTWORD are not considered
946 // for latest active to avoid masking regular clients started before
947 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
948 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
949 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700950 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
951 // is marked latest sensitive active even if another app qualifies.
952 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700953 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700954 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700955 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000956 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700957 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700958 latestSensitiveActiveOrComm = current;
959 latestSensitiveStartNs = current->startTimeNs;
960 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800961 }
962 isSensitiveActive = true;
963 } else {
964 if (current->startTimeNs > latestStartNs) {
965 latestActive = current;
966 latestStartNs = current->startTimeNs;
967 }
968 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800969 }
970 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000971 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
972 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700973 onlyHotwordActive = false;
974 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100975 if (currentUid == mPhoneStateOwnerUid &&
976 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700977 isPhoneStateOwnerActive = true;
978 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800979 }
980
Eric Laurent1ff16a72019-03-14 18:35:04 -0700981 // if no active client with UI on Top, consider latest active as top
982 if (topActive == nullptr) {
983 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800984 topStartNs = latestStartNs;
985 }
986 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700987 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800988 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700989 } else if (latestSensitiveActiveOrComm != nullptr) {
990 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
991 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700992 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000993 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700994 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700995 topSensitiveActive = latestSensitiveActiveOrComm;
996 topSensitiveStartNs = latestSensitiveStartNs;
997 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800998 }
999
1000 // If both privacy sensitive and regular capture are active:
1001 // if the regular capture is privileged
1002 // allow concurrency
1003 // else
1004 // favor the privacy sensitive case
1005 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001006 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001007 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001008 }
1009
1010 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1011 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001012 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001013 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001014 if (!current->active) {
1015 continue;
1016 }
1017
Eric Laurent4eb58f12018-12-07 16:41:02 -08001018 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001019 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001020 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001021 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001022 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001023 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1024 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001025
Andy Hung79eacdb2023-11-30 19:34:24 -08001026 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mMutex) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001027 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001028 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001029 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001030 bool canCaptureCommunication = recordClient->canCaptureOutput
1031 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001032 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001033 return !(isInCall && !canCaptureCall)
1034 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001035 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001036
1037 // By default allow capture if:
1038 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001039 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001040 // AND there is no active privacy sensitive capture or call
1041 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001042 bool allowSensitiveCapture =
1043 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001044 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001045 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001046 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001047 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001048
Eric Laurented726cc2021-07-01 14:26:41 +02001049 if (!current->hasOp()) {
1050 // Never allow capture if app op is denied
1051 allowCapture = false;
1052 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001053 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1054 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001055 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001056 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001057 // Active assistant list is not being used
1058 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001059 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001060 // OR there is no active privacy sensitive capture or call
1061 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1062 // AND is latest TOP assistant AND
1063 // uses VOICE_RECOGNITION OR uses HOTWORD
1064 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001065 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001066 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001067 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001068 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001069 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001070 && canCaptureIfInCallOrCommunication(current)) {
1071 if (isTopOrLatestAssistant
1072 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1073 || source == AUDIO_SOURCE_HOTWORD)) {
1074 allowCapture = true;
1075 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1076 allowCapture = true;
1077 }
1078 }
1079 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1080 // For assistant on active list and on top allow capture if:
1081 // An accessibility service is on TOP
1082 // AND the source is VOICE_RECOGNITION or HOTWORD
1083 // OR there is no active privacy sensitive capture or call
1084 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1085 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1086 if (isA11yOnTop) {
1087 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1088 allowCapture = true;
1089 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001090 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001091 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001092 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1093 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001094 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001095 }
1096 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001097 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001098 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001099 // The assistant is not on TOP
1100 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001101 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001102 // OR
1103 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1104 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001105 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001106 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001107 allowCapture = true;
1108 }
Eric Laurent589171c2019-07-25 18:04:29 -07001109 if (isA11yOnTop) {
1110 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1111 allowCapture = true;
1112 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001113 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001114 } else if (source == AUDIO_SOURCE_HOTWORD) {
1115 // For HOTWORD source allow capture when not on TOP if:
1116 // All active clients are using HOTWORD source
1117 // AND no call is active
1118 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001119 if (onlyHotwordActive
1120 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001121 allowCapture = true;
1122 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001123 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001124 // For current InputMethodService allow capture if:
1125 // A RTT call is active AND the source is VOICE_RECOGNITION
1126 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1127 allowCapture = true;
1128 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001129 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001130 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001131 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001132 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001133 }
1134}
1135
Michael Groovercfd28302018-12-11 19:16:46 -08001136void AudioPolicyService::silenceAllRecordings_l() {
1137 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1138 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001139 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001140 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001141 }
Michael Groovercfd28302018-12-11 19:16:46 -08001142 }
1143}
1144
Eric Laurente8c8b432018-10-17 10:08:02 -07001145/* static */
1146app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001147
1148 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001149 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001150 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1151 // include persistent services
1152 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001153 }
1154 return APP_STATE_FOREGROUND;
1155}
1156
Eric Laurent4eb58f12018-12-07 16:41:02 -08001157/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001158bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001159{
1160 switch (source) {
1161 case AUDIO_SOURCE_VOICE_UPLINK:
1162 case AUDIO_SOURCE_VOICE_DOWNLINK:
1163 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001164 case AUDIO_SOURCE_REMOTE_SUBMIX:
1165 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001166 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001167 return true;
1168 default:
1169 break;
1170 }
1171 return false;
1172}
1173
Eric Laurent8c7ef892021-06-10 13:32:16 +02001174void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001175{
1176 AutoCallerClear acc;
1177
1178 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001179 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001180 }
1181 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1182 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001183 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001184 if (client->silenced != silenced) {
1185 if (client->active) {
1186 if (silenced) {
1187 finishRecording(client->attributionSource, client->attributes.source);
1188 } else {
1189 std::stringstream msg;
1190 msg << "Audio recording un-silenced on session " << client->session;
1191 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1192 client->attributes.source)) {
1193 silenced = true;
1194 }
1195 }
1196 }
1197 af->setRecordSilenced(client->portId, silenced);
1198 client->silenced = silenced;
1199 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001200 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001201}
1202
Glenn Kasten0f11b512014-01-31 16:18:54 -08001203status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Andy Hung79eacdb2023-11-30 19:34:24 -08001204NO_THREAD_SAFETY_ANALYSIS // update for trylock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001205{
Glenn Kasten44deb052012-02-05 18:09:08 -08001206 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001207 dumpPermissionDenial(fd);
1208 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001209 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001210 if (!locked) {
1211 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001212 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001213 }
1214
1215 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001216
1217 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001218 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001219 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001220 mAudioCommandThread->dump(fd);
1221 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001222
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001223 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001224 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001225 if (mOutputCommandThread != 0) {
1226 mOutputCommandThread->dump(fd);
1227 }
1228
Eric Laurentdce54a12014-03-10 12:19:46 -07001229 if (mAudioPolicyManager) {
1230 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001231 } else {
1232 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001233 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001234 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001235
Kevin Rocard8be94972019-02-22 13:26:25 -08001236 mPackageManager.dump(fd);
1237
Andy Hung79eacdb2023-11-30 19:34:24 -08001238 dumpReleaseLock(mMutex, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001239
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001240 if (mSpatializer != nullptr) {
1241 std::string dumpString = mSpatializer->toString(1 /* level */);
1242 write(fd, dumpString.c_str(), dumpString.size());
1243 } else {
1244 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1245 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1246 }
1247
Andy Hungc747c532022-03-07 21:41:14 -08001248 {
1249 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1250 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1251 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1252 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001253 }
1254 return NO_ERROR;
1255}
1256
1257status_t AudioPolicyService::dumpPermissionDenial(int fd)
1258{
1259 const size_t SIZE = 256;
1260 char buffer[SIZE];
1261 String8 result;
1262 snprintf(buffer, SIZE, "Permission Denial: "
1263 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1264 IPCThreadState::self()->getCallingPid(),
1265 IPCThreadState::self()->getCallingUid());
1266 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001267 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001268 return NO_ERROR;
1269}
1270
1271status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001272 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001273 // make sure transactions reserved to AudioFlinger do not come from other processes
1274 switch (code) {
1275 case TRANSACTION_startOutput:
1276 case TRANSACTION_stopOutput:
1277 case TRANSACTION_releaseOutput:
1278 case TRANSACTION_getInputForAttr:
1279 case TRANSACTION_startInput:
1280 case TRANSACTION_stopInput:
1281 case TRANSACTION_releaseInput:
1282 case TRANSACTION_getOutputForEffect:
1283 case TRANSACTION_registerEffect:
1284 case TRANSACTION_unregisterEffect:
1285 case TRANSACTION_setEffectEnabled:
1286 case TRANSACTION_getStrategyForStream:
1287 case TRANSACTION_getOutputForAttr:
1288 case TRANSACTION_moveEffectsToIo:
1289 ALOGW("%s: transaction %d received from PID %d",
1290 __func__, code, IPCThreadState::self()->getCallingPid());
1291 return INVALID_OPERATION;
1292 default:
1293 break;
1294 }
1295
1296 // make sure the following transactions come from system components
1297 switch (code) {
1298 case TRANSACTION_setDeviceConnectionState:
1299 case TRANSACTION_handleDeviceConfigChange:
1300 case TRANSACTION_setPhoneState:
1301//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1302// case TRANSACTION_setForceUse:
1303 case TRANSACTION_initStreamVolume:
1304 case TRANSACTION_setStreamVolumeIndex:
1305 case TRANSACTION_setVolumeIndexForAttributes:
1306 case TRANSACTION_getStreamVolumeIndex:
1307 case TRANSACTION_getVolumeIndexForAttributes:
1308 case TRANSACTION_getMinVolumeIndexForAttributes:
1309 case TRANSACTION_getMaxVolumeIndexForAttributes:
1310 case TRANSACTION_isStreamActive:
1311 case TRANSACTION_isStreamActiveRemotely:
1312 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001313 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001314 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001315 case TRANSACTION_setMasterMono:
1316 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001317 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001318 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001319 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001320 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001321 case TRANSACTION_setA11yServicesUids:
1322 case TRANSACTION_setUidDeviceAffinities:
1323 case TRANSACTION_removeUidDeviceAffinities:
1324 case TRANSACTION_setUserIdDeviceAffinities:
1325 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001326 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001327 case TRANSACTION_listAudioVolumeGroups:
1328 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1329 case TRANSACTION_acquireSoundTriggerSession:
1330 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001331 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001332 case TRANSACTION_setRttEnabled:
1333 case TRANSACTION_isCallScreenModeSupported:
1334 case TRANSACTION_setDevicesRoleForStrategy:
1335 case TRANSACTION_setSupportedSystemUsages:
1336 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001337 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001338 case TRANSACTION_getDevicesForRoleAndStrategy:
1339 case TRANSACTION_getDevicesForAttributes:
1340 case TRANSACTION_setAllowedCapturePolicy:
1341 case TRANSACTION_onNewAudioModulesAvailable:
1342 case TRANSACTION_setCurrentImeUid:
1343 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1344 case TRANSACTION_setDevicesRoleForCapturePreset:
1345 case TRANSACTION_addDevicesRoleForCapturePreset:
1346 case TRANSACTION_removeDevicesRoleForCapturePreset:
1347 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001348 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001349 case TRANSACTION_getSpatializer:
1350 case TRANSACTION_setPreferredMixerAttributes:
1351 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001352 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1353 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1354 __func__, code, IPCThreadState::self()->getCallingPid(),
1355 IPCThreadState::self()->getCallingUid());
1356 return INVALID_OPERATION;
1357 }
1358 } break;
1359 default:
1360 break;
1361 }
1362
Andy Hungc747c532022-03-07 21:41:14 -08001363 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1364 mediautils::TimeCheck check(
1365 std::string("IAudioPolicyService::").append(methodName),
1366 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1367 if (timeout) {
1368 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1369 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1370 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1371 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1372 .record();
1373 } else {
1374 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1375 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001376 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1377 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1378 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001379
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001380 switch (code) {
1381 case SHELL_COMMAND_TRANSACTION: {
1382 int in = data.readFileDescriptor();
1383 int out = data.readFileDescriptor();
1384 int err = data.readFileDescriptor();
1385 int argc = data.readInt32();
1386 Vector<String16> args;
1387 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1388 args.add(data.readString16());
1389 }
1390 sp<IBinder> unusedCallback;
1391 sp<IResultReceiver> resultReceiver;
1392 status_t status;
1393 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1394 return status;
1395 }
1396 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1397 return status;
1398 }
1399 status = shellCommand(in, out, err, args);
1400 if (resultReceiver != nullptr) {
1401 resultReceiver->send(status);
1402 }
1403 return NO_ERROR;
1404 }
1405 }
1406
Mathias Agopian65ab4712010-07-14 17:59:35 -07001407 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1408}
1409
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001410// ------------------- Shell command implementation -------------------
1411
1412// NOTE: This is a remote API - make sure all args are validated
1413status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1414 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1415 return PERMISSION_DENIED;
1416 }
1417 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1418 return BAD_VALUE;
1419 }
jovanakbe066e12019-09-02 11:54:39 -07001420 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001421 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001422 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001423 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001424 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001425 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001426 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1427 purgePermissionCache();
1428 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001429 } else if (args.size() == 1 && args[0] == String16("help")) {
1430 printHelp(out);
1431 return NO_ERROR;
1432 }
1433 printHelp(err);
1434 return BAD_VALUE;
1435}
1436
jovanakbe066e12019-09-02 11:54:39 -07001437static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1438 if (userId < 0) {
1439 ALOGE("Invalid user: %d", userId);
1440 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001441 return BAD_VALUE;
1442 }
jovanakbe066e12019-09-02 11:54:39 -07001443
1444 PermissionController pc;
1445 uid = pc.getPackageUid(packageName, 0);
1446 if (uid <= 0) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001447 ALOGE("Unknown package: '%s'", String8(packageName).c_str());
1448 dprintf(err, "Unknown package: '%s'\n", String8(packageName).c_str());
jovanakbe066e12019-09-02 11:54:39 -07001449 return BAD_VALUE;
1450 }
1451
1452 uid = multiuser_get_uid(userId, uid);
1453 return NO_ERROR;
1454}
1455
1456status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1457 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1458 if (!(args.size() == 3 || args.size() == 5)) {
1459 printHelp(err);
1460 return BAD_VALUE;
1461 }
1462
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001463 bool active = false;
1464 if (args[2] == String16("active")) {
1465 active = true;
1466 } else if ((args[2] != String16("idle"))) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001467 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).c_str());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001468 return BAD_VALUE;
1469 }
jovanakbe066e12019-09-02 11:54:39 -07001470
1471 int userId = 0;
1472 if (args.size() >= 5 && args[3] == String16("--user")) {
1473 userId = atoi(String8(args[4]));
1474 }
1475
1476 uid_t uid;
1477 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1478 return BAD_VALUE;
1479 }
1480
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001481 sp<UidPolicy> uidPolicy;
1482 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001483 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001484 uidPolicy = mUidPolicy;
1485 }
1486 if (uidPolicy) {
1487 uidPolicy->addOverrideUid(uid, active);
1488 return NO_ERROR;
1489 }
1490 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001491}
1492
1493status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001494 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1495 if (!(args.size() == 2 || args.size() == 4)) {
1496 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001497 return BAD_VALUE;
1498 }
jovanakbe066e12019-09-02 11:54:39 -07001499
1500 int userId = 0;
1501 if (args.size() >= 4 && args[2] == String16("--user")) {
1502 userId = atoi(String8(args[3]));
1503 }
1504
1505 uid_t uid;
1506 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1507 return BAD_VALUE;
1508 }
1509
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001510 sp<UidPolicy> uidPolicy;
1511 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001512 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001513 uidPolicy = mUidPolicy;
1514 }
1515 if (uidPolicy) {
1516 uidPolicy->removeOverrideUid(uid);
1517 return NO_ERROR;
1518 }
1519 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001520}
1521
1522status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001523 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1524 if (!(args.size() == 2 || args.size() == 4)) {
1525 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001526 return BAD_VALUE;
1527 }
jovanakbe066e12019-09-02 11:54:39 -07001528
1529 int userId = 0;
1530 if (args.size() >= 4 && args[2] == String16("--user")) {
1531 userId = atoi(String8(args[3]));
1532 }
1533
1534 uid_t uid;
1535 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1536 return BAD_VALUE;
1537 }
1538
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001539 sp<UidPolicy> uidPolicy;
1540 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001541 audio_utils::lock_guard _l(mMutex);
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001542 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001543 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001544 if (uidPolicy) {
1545 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1546 }
1547 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001548}
1549
1550status_t AudioPolicyService::printHelp(int out) {
1551 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001552 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1553 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1554 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001555 " help print this message\n");
1556}
1557
Eric Laurent0d13fea2022-11-04 17:12:08 +01001558status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1559 const audio_config_base_t& config,
1560 const audio_output_flags_t flags) {
1561 return mUsecaseValidator->registerStream(output, config, flags);
1562}
1563
1564status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1565 return mUsecaseValidator->unregisterStream(output);
1566}
1567
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001568// ----------- AudioPolicyService::UidPolicy implementation ----------
1569
1570void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001571 status_t res = mAm.linkToDeath(this);
1572 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001573 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001574 | ActivityManager::UID_OBSERVER_ACTIVE
1575 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001576 ActivityManager::PROCESS_STATE_UNKNOWN,
1577 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001578 if (!res) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001579 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001580 mObserverRegistered = true;
1581 } else {
1582 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001583
Steven Moreland2f348142019-07-02 15:59:07 -07001584 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001585 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001586}
1587
1588void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001589 mAm.unlinkToDeath(this);
1590 mAm.unregisterUidObserver(this);
Andy Hung79eacdb2023-11-30 19:34:24 -08001591 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001592 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001593}
1594
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001595void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001596 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001597 mCachedUids.clear();
1598 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001599}
1600
Eric Laurente8c8b432018-10-17 10:08:02 -07001601void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001602 bool needToReregister = false;
1603 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001604 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001605 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001606 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001607 if (needToReregister) {
1608 // Looks like ActivityManager has died previously, attempt to re-register.
1609 registerSelf();
1610 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001611}
1612
1613bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1614 if (isServiceUid(uid)) return true;
1615 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001616 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001617 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001618 auto overrideIter = mOverrideUids.find(uid);
1619 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001620 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001621 }
1622 // In an absense of the ActivityManager, assume everything to be active.
1623 if (!mObserverRegistered) return true;
1624 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001625 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001626 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001627 }
1628 }
1629 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001630 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001631 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001632 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001633 mCachedUids.insert(std::pair<uid_t,
1634 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1635 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001636 }
1637 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001638}
1639
Eric Laurente8c8b432018-10-17 10:08:02 -07001640int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1641 if (isServiceUid(uid)) {
1642 return ActivityManager::PROCESS_STATE_TOP;
1643 }
1644 checkRegistered();
1645 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001646 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001647 auto overrideIter = mOverrideUids.find(uid);
1648 if (overrideIter != mOverrideUids.end()) {
1649 if (overrideIter->second.first) {
1650 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1651 return overrideIter->second.second;
1652 } else {
1653 auto cacheIter = mCachedUids.find(uid);
1654 if (cacheIter != mCachedUids.end()) {
1655 return cacheIter->second.second;
1656 }
1657 }
1658 }
1659 return ActivityManager::PROCESS_STATE_UNKNOWN;
1660 }
1661 // In an absense of the ActivityManager, assume everything to be active.
1662 if (!mObserverRegistered) {
1663 return ActivityManager::PROCESS_STATE_TOP;
1664 }
1665 auto cacheIter = mCachedUids.find(uid);
1666 if (cacheIter != mCachedUids.end()) {
1667 if (cacheIter->second.first) {
1668 return cacheIter->second.second;
1669 } else {
1670 return ActivityManager::PROCESS_STATE_UNKNOWN;
1671 }
1672 }
1673 }
1674 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001675 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001676 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1677 if (active) {
1678 state = am.getUidProcessState(uid, String16("audioserver"));
1679 }
1680 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001681 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001682 mCachedUids.insert(std::pair<uid_t,
1683 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1684 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001685
Eric Laurente8c8b432018-10-17 10:08:02 -07001686 return state;
1687}
1688
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001689void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001690 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001691}
1692
1693void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001694 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001695}
1696
1697void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001698 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001699}
1700
Eric Laurente8c8b432018-10-17 10:08:02 -07001701void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1702 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001703 int64_t procStateSeq __unused,
1704 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001705 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1706 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001707 }
1708}
1709
Austin Borgerdddb7552023-03-30 17:53:01 -07001710void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001711}
1712
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001713void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001714 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1715}
1716
1717void AudioPolicyService::UidPolicy::notifyService() {
1718 sp<AudioPolicyService> service = mService.promote();
1719 if (service != nullptr) {
1720 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001721 }
1722}
1723
Eric Laurente8c8b432018-10-17 10:08:02 -07001724void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1725 std::pair<bool, int>> *uids,
1726 uid_t uid,
1727 bool active,
1728 int state,
1729 bool insert) {
1730 if (isServiceUid(uid)) {
1731 return;
1732 }
1733 bool wasActive = isUidActive(uid);
1734 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001735 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001736 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001737 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001738 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001739 if (wasActive != isUidActive(uid) || state != previousState) {
1740 notifyService();
1741 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001742}
1743
Eric Laurente8c8b432018-10-17 10:08:02 -07001744void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1745 std::pair<bool, int>> *uids,
1746 uid_t uid,
1747 bool active,
1748 int state,
1749 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001750 auto it = uids->find(uid);
1751 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001752 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001753 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1754 it->second.first = active;
1755 }
1756 if (it->second.first) {
1757 it->second.second = state;
1758 } else {
1759 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1760 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001761 } else {
1762 uids->erase(it);
1763 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001764 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1765 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1766 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001767 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001768}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001769
Eric Laurent4eb58f12018-12-07 16:41:02 -08001770bool AudioPolicyService::UidPolicy::isA11yOnTop() {
Andy Hung79eacdb2023-11-30 19:34:24 -08001771 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001772 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001773 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001774 continue;
1775 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001776 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1777 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001778 return true;
1779 }
1780 }
1781 return false;
1782}
1783
Eric Laurentb78763e2018-10-17 10:08:02 -07001784bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1785{
1786 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1787 return it != mA11yUids.end();
1788}
1789
Oscar Azucena829d90d2022-01-28 17:17:56 -08001790void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1791 mAssistantUids.clear();
1792 mAssistantUids = uids;
1793}
1794
1795bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1796{
1797 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1798 return it != mAssistantUids.end();
1799}
1800
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001801void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1802 mActiveAssistantUids = activeUids;
1803}
1804
1805bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1806{
1807 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1808 mActiveAssistantUids.end(), uid);
1809 return it != mActiveAssistantUids.end();
1810}
1811
Oscar Azucena829d90d2022-01-28 17:17:56 -08001812void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1813 const size_t SIZE = 256;
1814 char buffer[SIZE];
1815 String8 result;
1816 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1817 snprintf(buffer, SIZE, "\t%s: \n", title);
1818 result.append(buffer);
1819 int counter = 0;
1820 if (uids.empty()) {
1821 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1822 result.append(buffer);
1823 return;
1824 }
1825 for (const auto &uid : uids) {
1826 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1827 result.append(buffer);
1828 }
1829 };
1830
1831 snprintf(buffer, SIZE, "UID Policy:\n");
1832 result.append(buffer);
1833 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1834 result.append(buffer);
1835
1836 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001837 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001838
1839 appendUidsToResult("Accessibility UIDs", mA11yUids);
1840
1841 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1842 result.append(buffer);
1843
1844 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1845 result.append(buffer);
1846
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001847 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001848}
1849
Michael Groovercfd28302018-12-11 19:16:46 -08001850// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1851void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1852 SensorPrivacyManager spm;
1853 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1854 spm.addSensorPrivacyListener(this);
1855}
1856
1857void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1858 SensorPrivacyManager spm;
1859 spm.removeSensorPrivacyListener(this);
1860}
1861
1862bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1863 return mSensorPrivacyEnabled;
1864}
1865
Evan Seversond8dc6832022-01-27 10:47:03 -08001866binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1867 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001868 mSensorPrivacyEnabled = enabled;
1869 sp<AudioPolicyService> service = mService.promote();
1870 if (service != nullptr) {
1871 service->updateUidStates();
1872 }
1873 return binder::Status::ok();
1874}
1875
Mathias Agopian65ab4712010-07-14 17:59:35 -07001876// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1877
Eric Laurentbfb1b832013-01-07 09:53:42 -08001878AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1879 const wp<AudioPolicyService>& service)
1880 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001881{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001882}
1883
1884
1885AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1886{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001887 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001888 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001889 }
1890 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001891}
1892
1893void AudioPolicyService::AudioCommandThread::onFirstRef()
1894{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001895 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001896}
1897
1898bool AudioPolicyService::AudioCommandThread::threadLoop()
1899{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001900 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001901
Andy Hung79eacdb2023-11-30 19:34:24 -08001902 audio_utils::unique_lock ul(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001903 while (!exitPending())
1904 {
Eric Laurent59a89232014-06-08 14:14:17 -07001905 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001906 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001907 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001908 nsecs_t curTime = systemTime();
1909 // commands are sorted by increasing time stamp: execute them from index 0 and up
1910 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001911 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001912 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001913 if (mAudioCommands.isEmpty()) {
1914 ++numTimesBecameEmpty;
1915 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001916 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001917
1918 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001919 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001920 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001921 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001922 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001923 ul.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001924 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1925 data->mVolume,
1926 data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001927 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001928 }break;
1929 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001930 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001931 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001932 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001933 ul.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001934 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hung79eacdb2023-11-30 19:34:24 -08001935 ul.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001936 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001937 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001938 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001939 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001940 data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001941 ul.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001942 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001943 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001944 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001945 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001946 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001947 ALOGV("AudioCommandThread() processing stop output portId %d",
1948 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001949 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001950 if (svc == 0) {
1951 break;
1952 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001953 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001954 svc->doStopOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001955 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001956 }break;
1957 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001958 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001959 ALOGV("AudioCommandThread() processing release output portId %d",
1960 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001961 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001962 if (svc == 0) {
1963 break;
1964 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001965 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001966 svc->doReleaseOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001967 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001968 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001969 case CREATE_AUDIO_PATCH: {
1970 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1971 ALOGV("AudioCommandThread() processing create audio patch");
1972 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1973 if (af == 0) {
1974 command->mStatus = PERMISSION_DENIED;
1975 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001976 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001977 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001978 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001979 }
1980 } break;
1981 case RELEASE_AUDIO_PATCH: {
1982 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1983 ALOGV("AudioCommandThread() processing release audio patch");
1984 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1985 if (af == 0) {
1986 command->mStatus = PERMISSION_DENIED;
1987 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001988 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001989 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001990 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001991 }
1992 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001993 case UPDATE_AUDIOPORT_LIST: {
1994 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001995 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001996 if (svc == 0) {
1997 break;
1998 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001999 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002000 svc->doOnAudioPortListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08002001 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002002 }break;
2003 case UPDATE_AUDIOPATCH_LIST: {
2004 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002005 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002006 if (svc == 0) {
2007 break;
2008 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002009 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002010 svc->doOnAudioPatchListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08002011 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07002012 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002013 case CHANGED_AUDIOVOLUMEGROUP: {
2014 AudioVolumeGroupData *data =
2015 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2016 ALOGV("AudioCommandThread() processing update audio volume group");
2017 svc = mService.promote();
2018 if (svc == 0) {
2019 break;
2020 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002021 ul.unlock();
François Gaffiecfe17322018-11-07 13:41:29 +01002022 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
Andy Hung79eacdb2023-11-30 19:34:24 -08002023 ul.lock();
François Gaffiecfe17322018-11-07 13:41:29 +01002024 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002025 case SET_AUDIOPORT_CONFIG: {
2026 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2027 ALOGV("AudioCommandThread() processing set port config");
2028 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2029 if (af == 0) {
2030 command->mStatus = PERMISSION_DENIED;
2031 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002032 ul.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002033 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hung79eacdb2023-11-30 19:34:24 -08002034 ul.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002035 }
2036 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002037 case DYN_POLICY_MIX_STATE_UPDATE: {
2038 DynPolicyMixStateUpdateData *data =
2039 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002040 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002041 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002042 svc = mService.promote();
2043 if (svc == 0) {
2044 break;
2045 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002046 ul.unlock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002047 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
Andy Hung79eacdb2023-11-30 19:34:24 -08002048 ul.lock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002049 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002050 case RECORDING_CONFIGURATION_UPDATE: {
2051 RecordingConfigurationUpdateData *data =
2052 (RecordingConfigurationUpdateData *)command->mParam.get();
2053 ALOGV("AudioCommandThread() processing recording configuration update");
2054 svc = mService.promote();
2055 if (svc == 0) {
2056 break;
2057 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002058 ul.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002059 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002060 &data->mClientConfig, data->mClientEffects,
2061 &data->mDeviceConfig, data->mEffects,
2062 data->mPatchHandle, data->mSource);
Andy Hung79eacdb2023-11-30 19:34:24 -08002063 ul.lock();
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002064 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002065 case SET_EFFECT_SUSPENDED: {
2066 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2067 ALOGV("AudioCommandThread() processing set effect suspended");
2068 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2069 if (af != 0) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002070 ul.unlock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002071 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
Andy Hung79eacdb2023-11-30 19:34:24 -08002072 ul.lock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002073 }
2074 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002075 case AUDIO_MODULES_UPDATE: {
2076 ALOGV("AudioCommandThread() processing audio modules update");
2077 svc = mService.promote();
2078 if (svc == 0) {
2079 break;
2080 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002081 ul.unlock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002082 svc->doOnNewAudioModulesAvailable();
Andy Hung79eacdb2023-11-30 19:34:24 -08002083 ul.lock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002084 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002085 case ROUTING_UPDATED: {
2086 ALOGV("AudioCommandThread() processing routing update");
2087 svc = mService.promote();
2088 if (svc == 0) {
2089 break;
2090 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002091 ul.unlock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002092 svc->doOnRoutingUpdated();
Andy Hung79eacdb2023-11-30 19:34:24 -08002093 ul.lock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002094 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002095
Eric Laurented726cc2021-07-01 14:26:41 +02002096 case UPDATE_UID_STATES: {
2097 ALOGV("AudioCommandThread() processing updateUID states");
2098 svc = mService.promote();
2099 if (svc == 0) {
2100 break;
2101 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002102 ul.unlock();
Eric Laurented726cc2021-07-01 14:26:41 +02002103 svc->updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -08002104 ul.lock();
Eric Laurented726cc2021-07-01 14:26:41 +02002105 } break;
2106
Eric Laurent15903592022-02-24 20:44:36 +01002107 case CHECK_SPATIALIZER_OUTPUT: {
2108 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002109 svc = mService.promote();
2110 if (svc == 0) {
2111 break;
2112 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002113 ul.unlock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002114 svc->doOnCheckSpatializer();
Andy Hung79eacdb2023-11-30 19:34:24 -08002115 ul.lock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002116 } break;
2117
Eric Laurent15903592022-02-24 20:44:36 +01002118 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2119 ALOGV("AudioCommandThread() processing update spatializer tracks");
2120 svc = mService.promote();
2121 if (svc == 0) {
2122 break;
2123 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002124 ul.unlock();
Eric Laurent15903592022-02-24 20:44:36 +01002125 svc->doOnUpdateActiveSpatializerTracks();
Andy Hung79eacdb2023-11-30 19:34:24 -08002126 ul.lock();
Eric Laurent15903592022-02-24 20:44:36 +01002127 } break;
2128
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002129 case VOL_RANGE_INIT_REQUEST: {
2130 ALOGV("AudioCommandThread() processing volume range init request");
2131 svc = mService.promote();
2132 if (svc == 0) {
2133 break;
2134 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002135 ul.unlock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002136 svc->doOnVolumeRangeInitRequest();
Andy Hung79eacdb2023-11-30 19:34:24 -08002137 ul.lock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002138 } break;
2139
Mathias Agopian65ab4712010-07-14 17:59:35 -07002140 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002141 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002142 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002143 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002144 audio_utils::lock_guard _l(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002145 if (command->mWaitStatus) {
2146 command->mWaitStatus = false;
Andy Hung79eacdb2023-11-30 19:34:24 -08002147 command->mCond.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002148 }
2149 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002150 waitTime = -1;
Andy Hung79eacdb2023-11-30 19:34:24 -08002151 // release ul before releasing strong reference on the service as
Zach Janga754b4f2015-10-27 01:29:34 +00002152 // AudioPolicyService destructor calls AudioCommandThread::exit() which
Andy Hung79eacdb2023-11-30 19:34:24 -08002153 // acquires ul.
2154 ul.unlock();
Zach Janga754b4f2015-10-27 01:29:34 +00002155 svc.clear();
Andy Hung79eacdb2023-11-30 19:34:24 -08002156 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002157 } else {
2158 waitTime = mAudioCommands[0]->mTime - curTime;
2159 break;
2160 }
2161 }
Zach Janga754b4f2015-10-27 01:29:34 +00002162
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002163 // release delayed commands wake lock as many times as we made the queue is
2164 // empty during popping.
2165 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002166 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002167 }
2168
2169 // At this stage we have either an empty command queue or the first command in the queue
2170 // has a finite delay. So unless we are exiting it is safe to wait.
2171 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002172 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002173 if (waitTime == -1) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002174 mWaitWorkCV.wait(ul);
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002175 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002176 // discard return value.
2177 mWaitWorkCV.wait_for(ul, std::chrono::nanoseconds(waitTime));
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002178 }
Eric Laurent59a89232014-06-08 14:14:17 -07002179 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002180 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002181 // release delayed commands wake lock before quitting
2182 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002183 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002184 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002185 return false;
2186}
2187
2188status_t AudioPolicyService::AudioCommandThread::dump(int fd)
Andy Hung79eacdb2023-11-30 19:34:24 -08002189NO_THREAD_SAFETY_ANALYSIS // trylock
Mathias Agopian65ab4712010-07-14 17:59:35 -07002190{
2191 const size_t SIZE = 256;
2192 char buffer[SIZE];
2193 String8 result;
2194
Andy Hung79eacdb2023-11-30 19:34:24 -08002195 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002196 if (!locked) {
2197 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002198 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002199 }
2200
2201 snprintf(buffer, SIZE, "- Commands:\n");
2202 result = String8(buffer);
2203 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002204 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002205 mAudioCommands[i]->dump(buffer, SIZE);
2206 result.append(buffer);
2207 }
2208 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002209 if (mLastCommand != 0) {
2210 mLastCommand->dump(buffer, SIZE);
2211 result.append(buffer);
2212 } else {
2213 result.append(" none\n");
2214 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002215
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002216 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002217
Andy Hung79eacdb2023-11-30 19:34:24 -08002218 dumpReleaseLock(mMutex, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002219
2220 return NO_ERROR;
2221}
2222
Glenn Kastenfff6d712012-01-12 16:38:12 -08002223status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002224 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002225 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002226 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002227{
Eric Laurent0ede8922014-05-09 18:04:42 -07002228 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002229 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002230 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002231 data->mStream = stream;
2232 data->mVolume = volume;
2233 data->mIO = output;
2234 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002235 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002236 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002237 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002238 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002239}
2240
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002241status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002242 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002243 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002244{
Eric Laurent0ede8922014-05-09 18:04:42 -07002245 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002246 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002247 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002248 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002249 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002250 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002251 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002252 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002253 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002254 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002255}
2256
2257status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2258{
Eric Laurent0ede8922014-05-09 18:04:42 -07002259 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002260 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002261 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002262 data->mVolume = volume;
2263 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002264 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002265 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002266 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002267}
2268
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002269void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2270 audio_session_t sessionId,
2271 bool suspended)
2272{
2273 sp<AudioCommand> command = new AudioCommand();
2274 command->mCommand = SET_EFFECT_SUSPENDED;
2275 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2276 data->mEffectId = effectId;
2277 data->mSessionId = sessionId;
2278 data->mSuspended = suspended;
2279 command->mParam = data;
2280 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2281 effectId, sessionId, suspended);
2282 sendCommand(command);
2283}
2284
2285
Eric Laurentd7fe0862018-07-14 16:48:01 -07002286void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002287{
Eric Laurent0ede8922014-05-09 18:04:42 -07002288 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002289 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002290 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002291 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002292 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002293 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002294 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002295}
2296
Eric Laurentd7fe0862018-07-14 16:48:01 -07002297void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002298{
Eric Laurent0ede8922014-05-09 18:04:42 -07002299 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002300 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002301 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002302 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002303 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002304 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002305 sendCommand(command);
2306}
2307
Eric Laurent951f4552014-05-20 10:48:17 -07002308status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2309 const struct audio_patch *patch,
2310 audio_patch_handle_t *handle,
2311 int delayMs)
2312{
2313 status_t status = NO_ERROR;
2314
2315 sp<AudioCommand> command = new AudioCommand();
2316 command->mCommand = CREATE_AUDIO_PATCH;
2317 CreateAudioPatchData *data = new CreateAudioPatchData();
2318 data->mPatch = *patch;
2319 data->mHandle = *handle;
2320 command->mParam = data;
2321 command->mWaitStatus = true;
2322 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2323 status = sendCommand(command, delayMs);
2324 if (status == NO_ERROR) {
2325 *handle = data->mHandle;
2326 }
2327 return status;
2328}
2329
2330status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2331 int delayMs)
2332{
2333 sp<AudioCommand> command = new AudioCommand();
2334 command->mCommand = RELEASE_AUDIO_PATCH;
2335 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2336 data->mHandle = handle;
2337 command->mParam = data;
2338 command->mWaitStatus = true;
2339 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2340 return sendCommand(command, delayMs);
2341}
2342
Eric Laurentb52c1522014-05-20 11:27:36 -07002343void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2344{
2345 sp<AudioCommand> command = new AudioCommand();
2346 command->mCommand = UPDATE_AUDIOPORT_LIST;
2347 ALOGV("AudioCommandThread() adding update audio port list");
2348 sendCommand(command);
2349}
2350
Eric Laurented726cc2021-07-01 14:26:41 +02002351void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2352{
2353 sp<AudioCommand> command = new AudioCommand();
2354 command->mCommand = UPDATE_UID_STATES;
2355 ALOGV("AudioCommandThread() adding update UID states");
2356 sendCommand(command);
2357}
2358
Eric Laurentb52c1522014-05-20 11:27:36 -07002359void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2360{
2361 sp<AudioCommand>command = new AudioCommand();
2362 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2363 ALOGV("AudioCommandThread() adding update audio patch list");
2364 sendCommand(command);
2365}
2366
François Gaffiecfe17322018-11-07 13:41:29 +01002367void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2368 int flags)
2369{
2370 sp<AudioCommand>command = new AudioCommand();
2371 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2372 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2373 data->mGroup = group;
2374 data->mFlags = flags;
2375 command->mParam = data;
2376 ALOGV("AudioCommandThread() adding audio volume group changed");
2377 sendCommand(command);
2378}
2379
Eric Laurente1715a42014-05-20 11:30:42 -07002380status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2381 const struct audio_port_config *config, int delayMs)
2382{
2383 sp<AudioCommand> command = new AudioCommand();
2384 command->mCommand = SET_AUDIOPORT_CONFIG;
2385 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2386 data->mConfig = *config;
2387 command->mParam = data;
2388 command->mWaitStatus = true;
2389 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2390 return sendCommand(command, delayMs);
2391}
2392
Jean-Michel Trivide801052015-04-14 19:10:14 -07002393void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002394 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002395{
2396 sp<AudioCommand> command = new AudioCommand();
2397 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2398 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2399 data->mRegId = regId;
2400 data->mState = state;
2401 command->mParam = data;
2402 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002403 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002404 sendCommand(command);
2405}
2406
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002407void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002408 int event,
2409 const record_client_info_t *clientInfo,
2410 const audio_config_base_t *clientConfig,
2411 std::vector<effect_descriptor_t> clientEffects,
2412 const audio_config_base_t *deviceConfig,
2413 std::vector<effect_descriptor_t> effects,
2414 audio_patch_handle_t patchHandle,
2415 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002416{
2417 sp<AudioCommand>command = new AudioCommand();
2418 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2419 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2420 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002421 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002422 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002423 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002424 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002425 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002426 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002427 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002428 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002429 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2430 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002431 sendCommand(command);
2432}
2433
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002434void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2435{
2436 sp<AudioCommand> command = new AudioCommand();
2437 command->mCommand = AUDIO_MODULES_UPDATE;
2438 sendCommand(command);
2439}
2440
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002441void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2442{
2443 sp<AudioCommand>command = new AudioCommand();
2444 command->mCommand = ROUTING_UPDATED;
2445 ALOGV("AudioCommandThread() adding routing update");
2446 sendCommand(command);
2447}
2448
Eric Laurent81dd0f52021-07-05 11:54:40 +02002449void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2450{
2451 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002452 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002453 ALOGV("AudioCommandThread() adding check spatializer");
2454 sendCommand(command);
2455}
2456
Eric Laurent15903592022-02-24 20:44:36 +01002457void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2458{
2459 sp<AudioCommand>command = new AudioCommand();
2460 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2461 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2462 sendCommand(command);
2463}
2464
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002465void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2466{
2467 sp<AudioCommand>command = new AudioCommand();
2468 command->mCommand = VOL_RANGE_INIT_REQUEST;
2469 ALOGV("AudioCommandThread() adding volume range init request");
2470 sendCommand(command);
2471}
2472
Eric Laurent0ede8922014-05-09 18:04:42 -07002473status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2474{
2475 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002476 audio_utils::lock_guard _l(mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002477 insertCommand_l(command, delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002478 mWaitWorkCV.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002479 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002480 audio_utils::unique_lock ul(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002481 while (command->mWaitStatus) {
2482 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002483 if (command->mCond.wait_for(
Andy Hung02ea2a02024-01-25 17:02:30 -08002484 ul, std::chrono::nanoseconds(timeOutNs), getTid()) == std::cv_status::timeout) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002485 command->mStatus = TIMED_OUT;
2486 command->mWaitStatus = false;
2487 }
2488 }
2489 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002490}
2491
Andy Hung79eacdb2023-11-30 19:34:24 -08002492// insertCommand_l() must be called with mMutex held
Eric Laurent0ede8922014-05-09 18:04:42 -07002493void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002494{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002495 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002496 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002497 command->mTime = systemTime() + milliseconds(delayMs);
2498
2499 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002500 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002501 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002502 }
2503
2504 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002505 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002506 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002507 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2508 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002509
2510 // create audio patch or release audio patch commands are equivalent
2511 // with regard to filtering
2512 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2513 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2514 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2515 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2516 continue;
2517 }
2518 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002519
2520 switch (command->mCommand) {
2521 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002522 ParametersData *data = (ParametersData *)command->mParam.get();
2523 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002524 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002525 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002526 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002527 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2528 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2529 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002530 String8 key;
2531 String8 value;
2532 param.getAt(j, key, value);
2533 for (size_t k = 0; k < param2.size(); k++) {
2534 String8 key2;
2535 String8 value2;
2536 param2.getAt(k, key2, value2);
2537 if (key2 == key) {
2538 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002539 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002540 break;
2541 }
2542 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002543 }
2544 // if all keys have been filtered out, remove the command.
2545 // otherwise, update the key value pairs
2546 if (param2.size() == 0) {
2547 removedCommands.add(command2);
2548 } else {
2549 data2->mKeyValuePairs = param2.toString();
2550 }
Eric Laurent21e54562013-09-23 12:08:05 -07002551 command->mTime = command2->mTime;
2552 // force delayMs to non 0 so that code below does not request to wait for
2553 // command status as the command is now delayed
2554 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002555 } break;
2556
2557 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002558 VolumeData *data = (VolumeData *)command->mParam.get();
2559 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002560 if (data->mIO != data2->mIO) break;
2561 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002562 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002563 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002564 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002565 command->mTime = command2->mTime;
2566 // force delayMs to non 0 so that code below does not request to wait for
2567 // command status as the command is now delayed
2568 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002569 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002570
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002571 case SET_VOICE_VOLUME: {
2572 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2573 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2574 ALOGV("Filtering out voice volume command value %f replaced by %f",
2575 data2->mVolume, data->mVolume);
2576 removedCommands.add(command2);
2577 command->mTime = command2->mTime;
2578 // force delayMs to non 0 so that code below does not request to wait for
2579 // command status as the command is now delayed
2580 delayMs = 1;
2581 } break;
2582
Eric Laurente45b48a2014-09-04 16:40:57 -07002583 case CREATE_AUDIO_PATCH:
2584 case RELEASE_AUDIO_PATCH: {
2585 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002586 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002587 if (command->mCommand == CREATE_AUDIO_PATCH) {
2588 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002589 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002590 } else {
2591 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002592 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002593 }
2594 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002595 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002596 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2597 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002598 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002599 } else {
2600 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002601 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002602 }
2603 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002604 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2605 same output. */
2606 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2607 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2608 bool isOutputDiff = false;
2609 if (patch.num_sources == patch2.num_sources) {
2610 for (unsigned count = 0; count < patch.num_sources; count++) {
2611 if (patch.sources[count].id != patch2.sources[count].id) {
2612 isOutputDiff = true;
2613 break;
2614 }
2615 }
2616 if (isOutputDiff)
2617 break;
2618 }
2619 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002620 ALOGV("Filtering out %s audio patch command for handle %d",
2621 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2622 removedCommands.add(command2);
2623 command->mTime = command2->mTime;
2624 // force delayMs to non 0 so that code below does not request to wait for
2625 // command status as the command is now delayed
2626 delayMs = 1;
2627 } break;
2628
Jean-Michel Trivide801052015-04-14 19:10:14 -07002629 case DYN_POLICY_MIX_STATE_UPDATE: {
2630
2631 } break;
2632
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002633 case RECORDING_CONFIGURATION_UPDATE: {
2634
2635 } break;
2636
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002637 case ROUTING_UPDATED: {
2638
2639 } break;
2640
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002641 case VOL_RANGE_INIT_REQUEST: {
2642 // command may come from different requests, do not filter
2643 } break;
2644
Mathias Agopian65ab4712010-07-14 17:59:35 -07002645 default:
2646 break;
2647 }
2648 }
2649
2650 // remove filtered commands
2651 for (size_t j = 0; j < removedCommands.size(); j++) {
2652 // removed commands always have time stamps greater than current command
2653 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002654 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002655 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002656 mAudioCommands.removeAt(k);
2657 break;
2658 }
2659 }
2660 }
2661 removedCommands.clear();
2662
Eric Laurentaa79bef2015-01-15 14:33:51 -08002663 // Disable wait for status if delay is not 0.
2664 // Except for create audio patch command because the returned patch handle
2665 // is needed by audio policy manager
2666 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002667 command->mWaitStatus = false;
2668 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002669
Mathias Agopian65ab4712010-07-14 17:59:35 -07002670 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002671 ALOGV("inserting command: %d at index %zd, num commands %zu",
2672 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002673 mAudioCommands.insertAt(command, i + 1);
2674}
2675
2676void AudioPolicyService::AudioCommandThread::exit()
2677{
Steve Block3856b092011-10-20 11:56:00 +01002678 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002679 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002680 audio_utils::lock_guard _l(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002681 requestExit();
Andy Hung79eacdb2023-11-30 19:34:24 -08002682 mWaitWorkCV.notify_one();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002683 }
Zach Janga754b4f2015-10-27 01:29:34 +00002684 // Note that we can call it from the thread loop if all other references have been released
2685 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002686 requestExitAndWait();
2687}
2688
2689void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2690{
2691 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2692 mCommand,
2693 (int)ns2s(mTime),
2694 (int)ns2ms(mTime)%1000,
2695 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002696 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002697}
2698
Dima Zavinfce7a472011-04-19 22:30:36 -07002699/******* helpers for the service_ops callbacks defined below *********/
2700void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2701 const char *keyValuePairs,
2702 int delayMs)
2703{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002704 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002705 delayMs);
2706}
2707
2708int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2709 float volume,
2710 audio_io_handle_t output,
2711 int delayMs)
2712{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002713 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002714 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002715}
2716
Dima Zavinfce7a472011-04-19 22:30:36 -07002717int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2718{
2719 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2720}
2721
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002722void AudioPolicyService::setEffectSuspended(int effectId,
2723 audio_session_t sessionId,
2724 bool suspended)
2725{
2726 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2727}
2728
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002729Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002730{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002731 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002732 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002733}
2734
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002735
Dima Zavinfce7a472011-04-19 22:30:36 -07002736extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002737audio_module_handle_t aps_load_hw_module(void *service __unused,
2738 const char *name);
2739audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002740 audio_devices_t *pDevices,
2741 uint32_t *pSamplingRate,
2742 audio_format_t *pFormat,
2743 audio_channel_mask_t *pChannelMask,
2744 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002745 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002746
Eric Laurent2d388ec2014-03-07 13:25:54 -08002747audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002748 audio_module_handle_t module,
2749 audio_devices_t *pDevices,
2750 uint32_t *pSamplingRate,
2751 audio_format_t *pFormat,
2752 audio_channel_mask_t *pChannelMask,
2753 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002754 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002755 const audio_offload_info_t *offloadInfo);
2756audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002757 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002758 audio_io_handle_t output2);
2759int aps_close_output(void *service __unused, audio_io_handle_t output);
2760int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2761int aps_restore_output(void *service __unused, audio_io_handle_t output);
2762audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002763 audio_devices_t *pDevices,
2764 uint32_t *pSamplingRate,
2765 audio_format_t *pFormat,
2766 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002767 audio_in_acoustics_t acoustics __unused);
2768audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002769 audio_module_handle_t module,
2770 audio_devices_t *pDevices,
2771 uint32_t *pSamplingRate,
2772 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002773 audio_channel_mask_t *pChannelMask);
2774int aps_close_input(void *service __unused, audio_io_handle_t input);
2775int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002776int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002777 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002778 audio_io_handle_t dst_output);
2779char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2780 const char *keys);
2781void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2782 const char *kv_pairs, int delay_ms);
2783int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002784 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002785 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002786int aps_set_voice_volume(void *service, float volume, int delay_ms);
2787};
Dima Zavinfce7a472011-04-19 22:30:36 -07002788
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002789} // namespace android