blob: d136f71475cedbf485bc12b6bcfa99922a4d5fd2 [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;
Mathias Agopian65ab4712010-07-14 17:59:35 -070055
Glenn Kasten8dad0e32012-01-09 08:41:22 -080056static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
57static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053058static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
Mathias Agopian65ab4712010-07-14 17:59:35 -070059
Mikhail Naganov959e2d02019-03-28 11:08:19 -070060static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Mathias Agopian65ab4712010-07-14 17:59:35 -070061
Eric Laurent0ede8922014-05-09 18:04:42 -070062static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010063
Svet Ganovf4ddfef2018-01-16 07:37:58 -080064static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070065
Andy Hungc747c532022-03-07 21:41:14 -080066// Creates an association between Binder code to name for IAudioPolicyService.
67#define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
68BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
69BINDER_METHOD_ENTRY(setDeviceConnectionState) \
70BINDER_METHOD_ENTRY(getDeviceConnectionState) \
71BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
72BINDER_METHOD_ENTRY(setPhoneState) \
73BINDER_METHOD_ENTRY(setForceUse) \
74BINDER_METHOD_ENTRY(getForceUse) \
75BINDER_METHOD_ENTRY(getOutput) \
76BINDER_METHOD_ENTRY(getOutputForAttr) \
77BINDER_METHOD_ENTRY(startOutput) \
78BINDER_METHOD_ENTRY(stopOutput) \
79BINDER_METHOD_ENTRY(releaseOutput) \
80BINDER_METHOD_ENTRY(getInputForAttr) \
81BINDER_METHOD_ENTRY(startInput) \
82BINDER_METHOD_ENTRY(stopInput) \
83BINDER_METHOD_ENTRY(releaseInput) \
84BINDER_METHOD_ENTRY(initStreamVolume) \
85BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
86BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
87BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
88BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
90BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
91BINDER_METHOD_ENTRY(getStrategyForStream) \
92BINDER_METHOD_ENTRY(getDevicesForAttributes) \
93BINDER_METHOD_ENTRY(getOutputForEffect) \
94BINDER_METHOD_ENTRY(registerEffect) \
95BINDER_METHOD_ENTRY(unregisterEffect) \
96BINDER_METHOD_ENTRY(setEffectEnabled) \
97BINDER_METHOD_ENTRY(moveEffectsToIo) \
98BINDER_METHOD_ENTRY(isStreamActive) \
99BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
100BINDER_METHOD_ENTRY(isSourceActive) \
101BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
102BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
103BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
104BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
105BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
106BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
107BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
108BINDER_METHOD_ENTRY(getOffloadSupport) \
109BINDER_METHOD_ENTRY(isDirectOutputSupported) \
110BINDER_METHOD_ENTRY(listAudioPorts) \
111BINDER_METHOD_ENTRY(getAudioPort) \
112BINDER_METHOD_ENTRY(createAudioPatch) \
113BINDER_METHOD_ENTRY(releaseAudioPatch) \
114BINDER_METHOD_ENTRY(listAudioPatches) \
115BINDER_METHOD_ENTRY(setAudioPortConfig) \
116BINDER_METHOD_ENTRY(registerClient) \
117BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
118BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
119BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
120BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
121BINDER_METHOD_ENTRY(getPhoneState) \
122BINDER_METHOD_ENTRY(registerPolicyMixes) \
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200123BINDER_METHOD_ENTRY(updatePolicyMixes) \
Andy Hungc747c532022-03-07 21:41:14 -0800124BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
125BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
126BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
127BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
128BINDER_METHOD_ENTRY(startAudioSource) \
129BINDER_METHOD_ENTRY(stopAudioSource) \
130BINDER_METHOD_ENTRY(setMasterMono) \
131BINDER_METHOD_ENTRY(getMasterMono) \
132BINDER_METHOD_ENTRY(getStreamVolumeDB) \
133BINDER_METHOD_ENTRY(getSurroundFormats) \
134BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
135BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
136BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
137BINDER_METHOD_ENTRY(setAssistantServicesUids) \
138BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
139BINDER_METHOD_ENTRY(setA11yServicesUids) \
140BINDER_METHOD_ENTRY(setCurrentImeUid) \
141BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
142BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800143BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800144BINDER_METHOD_ENTRY(listAudioProductStrategies) \
145BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
146BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
147BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
148BINDER_METHOD_ENTRY(setRttEnabled) \
149BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
150BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
151BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000152BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800153BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
154BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
157BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
158BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
159BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
160BINDER_METHOD_ENTRY(getSpatializer) \
161BINDER_METHOD_ENTRY(canBeSpatialized) \
162BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000163BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
164BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
165BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
166BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
167BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800168
169// singleton for Binder Method Statistics for IAudioPolicyService
170static auto& getIAudioPolicyServiceStatistics() {
171 using Code = int;
172
173#pragma push_macro("BINDER_METHOD_ENTRY")
174#undef BINDER_METHOD_ENTRY
175#define BINDER_METHOD_ENTRY(ENTRY) \
176 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
177
178 static mediautils::MethodStatistics<Code> methodStatistics{
179 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
180 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
181 };
182#pragma pop_macro("BINDER_METHOD_ENTRY")
183
184 return methodStatistics;
185}
186
Mathias Agopian65ab4712010-07-14 17:59:35 -0700187// ----------------------------------------------------------------------------
188
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530189static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
190{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700191 AudioPolicyManager *apm = nullptr;
192 media::AudioPolicyConfig apmConfig;
193 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
194 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
195 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
196 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
197 "Only default engine is currently supported with the AIDL HAL");
198 apm = new AudioPolicyManager(config,
199 loadApmEngineLibraryAndCreateEngine(
200 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
201 clientInterface);
202 } else {
203 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
204 apm = new AudioPolicyManager(config,
205 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
206 clientInterface);
207 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530208 status_t status = apm->initialize();
209 if (status != NO_ERROR) {
210 delete apm;
211 apm = nullptr;
212 }
213 return apm;
214}
215
216static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
217{
218 delete interface;
219}
220// ----------------------------------------------------------------------------
221
Mathias Agopian65ab4712010-07-14 17:59:35 -0700222AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700223 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700224 mAudioPolicyManager(NULL),
225 mAudioPolicyClient(NULL),
226 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530227 mCaptureStateNotifier(false),
228 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100229 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
230 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800231 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530232}
233
234void AudioPolicyService::loadAudioPolicyManager()
235{
236 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
237 if (mLibraryHandle != nullptr) {
238 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
239 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
240 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
241 const char *lastError = dlerror();
242 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
243 __func__, lastError != nullptr ? lastError : "no error");
244
245 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
246 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
247 lastError = dlerror();
248 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
249 __func__, lastError != nullptr ? lastError : "no error");
250 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
251 unloadAudioPolicyManager();
252 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
253 }
254 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700255}
256
257void AudioPolicyService::onFirstRef()
258{
Andy Hungd47aca22022-03-15 11:50:51 -0700259 // Log an AudioPolicy "constructor" mediametrics event on first ref.
260 // This records the time it takes to load the audio modules and devices.
261 mediametrics::Defer defer([beginNs = systemTime()] {
262 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
263 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
264 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
265 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700266 {
267 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800268
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700269 // start audio commands thread
270 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
271 // start output activity command thread
272 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700273
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700274 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530275
276 loadAudioPolicyManager();
277 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700278 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200279
bryant_liuba2b4392014-06-11 16:49:30 +0800280 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000281 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
282 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects(effectsFactoryHal);
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000283 sp<UidPolicy> uidPolicy = new UidPolicy(this);
284 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700285 {
286 Mutex::Autolock _l(mLock);
287 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000288 mUidPolicy = uidPolicy;
289 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700290 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000291 uidPolicy->registerSelf();
292 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200293
Eric Laurent81dd0f52021-07-05 11:54:40 +0200294 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200295 if (mAudioPolicyManager != nullptr) {
296 Mutex::Autolock _l(mLock);
297 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
298 AudioDeviceTypeAddrVector devices;
299 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
300 if (hasSpatializer) {
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000301 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200302 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700303 if (mSpatializer == nullptr) {
304 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
305 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
306 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
307 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200308 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200309 AudioSystem::audioPolicyReady();
François Gaffie163ce832023-06-28 11:36:35 +0200310 // AudioFlinger will handle effect creation and register these effects on audio_policy
311 // service. Hence, audio_policy service must be ready.
312 audioPolicyEffects->setDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700313}
314
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530315void AudioPolicyService::unloadAudioPolicyManager()
316{
317 ALOGV("%s ", __func__);
318 if (mLibraryHandle != nullptr) {
319 dlclose(mLibraryHandle);
320 }
321 mLibraryHandle = nullptr;
322 mCreateAudioPolicyManager = nullptr;
323 mDestroyAudioPolicyManager = nullptr;
324}
325
Mathias Agopian65ab4712010-07-14 17:59:35 -0700326AudioPolicyService::~AudioPolicyService()
327{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700328 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700329 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700330
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530331 mDestroyAudioPolicyManager(mAudioPolicyManager);
332 unloadAudioPolicyManager();
333
Eric Laurentdce54a12014-03-10 12:19:46 -0700334 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700335
336 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800337 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800338
339 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800340 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000341
342 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800343 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700344}
345
346// A notification client is always registered by AudioSystem when the client process
347// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800348Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700349{
Eric Laurent12590252015-08-21 18:40:20 -0700350 if (client == 0) {
351 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800352 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700353 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800354 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700355
356 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800357 pid_t pid = IPCThreadState::self()->getCallingPid();
358 int64_t token = ((int64_t)uid<<32) | pid;
359
360 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700361 sp<NotificationClient> notificationClient = new NotificationClient(this,
362 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800363 uid,
364 pid);
365 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700366
luochaojiang908c7d72018-06-21 14:58:04 +0800367 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700368
Marco Nelissenf8880202014-11-14 07:58:25 -0800369 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700370 binder->linkToDeath(notificationClient);
371 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800372 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700373}
374
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800375Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700376{
377 Mutex::Autolock _l(mNotificationClientsLock);
378
379 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800380 pid_t pid = IPCThreadState::self()->getCallingPid();
381 int64_t token = ((int64_t)uid<<32) | pid;
382
383 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800384 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700385 }
luochaojiang908c7d72018-06-21 14:58:04 +0800386 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800387 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700388}
389
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800390Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100391{
392 Mutex::Autolock _l(mNotificationClientsLock);
393
394 uid_t uid = IPCThreadState::self()->getCallingUid();
395 pid_t pid = IPCThreadState::self()->getCallingPid();
396 int64_t token = ((int64_t)uid<<32) | pid;
397
398 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800399 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100400 }
401 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800402 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100403}
404
Eric Laurentb52c1522014-05-20 11:27:36 -0700405// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800406void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700407{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000408 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800409 {
410 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800411 int64_t token = ((int64_t)uid<<32) | pid;
412 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800413 for (size_t i = 0; i < mNotificationClients.size(); i++) {
414 if (mNotificationClients.valueAt(i)->uid() == uid) {
415 hasSameUid = true;
416 break;
417 }
418 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000419 }
420 {
421 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800422 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700423 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700424 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700425 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800426 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700427}
428
429void AudioPolicyService::onAudioPortListUpdate()
430{
431 mOutputCommandThread->updateAudioPortListCommand();
432}
433
434void AudioPolicyService::doOnAudioPortListUpdate()
435{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800436 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700437 for (size_t i = 0; i < mNotificationClients.size(); i++) {
438 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
439 }
440}
441
442void AudioPolicyService::onAudioPatchListUpdate()
443{
444 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700445}
446
Eric Laurentb52c1522014-05-20 11:27:36 -0700447void AudioPolicyService::doOnAudioPatchListUpdate()
448{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800449 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700450 for (size_t i = 0; i < mNotificationClients.size(); i++) {
451 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
452 }
453}
454
François Gaffiecfe17322018-11-07 13:41:29 +0100455void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
456{
457 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
458}
459
460void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
461{
462 Mutex::Autolock _l(mNotificationClientsLock);
463 for (size_t i = 0; i < mNotificationClients.size(); i++) {
464 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
465 }
466}
467
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700468void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700469{
470 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000471 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700472 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
473}
474
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700475void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700476{
477 Mutex::Autolock _l(mNotificationClientsLock);
478 for (size_t i = 0; i < mNotificationClients.size(); i++) {
479 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
480 }
481}
482
Eric Laurenta9f86652018-11-28 17:23:11 -0800483void AudioPolicyService::onRecordingConfigurationUpdate(
484 int event,
485 const record_client_info_t *clientInfo,
486 const audio_config_base_t *clientConfig,
487 std::vector<effect_descriptor_t> clientEffects,
488 const audio_config_base_t *deviceConfig,
489 std::vector<effect_descriptor_t> effects,
490 audio_patch_handle_t patchHandle,
491 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800492{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800493 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800494 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800495}
496
Eric Laurenta9f86652018-11-28 17:23:11 -0800497void AudioPolicyService::doOnRecordingConfigurationUpdate(
498 int event,
499 const record_client_info_t *clientInfo,
500 const audio_config_base_t *clientConfig,
501 std::vector<effect_descriptor_t> clientEffects,
502 const audio_config_base_t *deviceConfig,
503 std::vector<effect_descriptor_t> effects,
504 audio_patch_handle_t patchHandle,
505 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800506{
507 Mutex::Autolock _l(mNotificationClientsLock);
508 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800509 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800510 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800511 }
512}
513
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700514void AudioPolicyService::onRoutingUpdated()
515{
516 mOutputCommandThread->routingChangedCommand();
517}
518
519void AudioPolicyService::doOnRoutingUpdated()
520{
521 Mutex::Autolock _l(mNotificationClientsLock);
522 for (size_t i = 0; i < mNotificationClients.size(); i++) {
523 mNotificationClients.valueAt(i)->onRoutingUpdated();
524 }
525}
526
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000527void AudioPolicyService::onVolumeRangeInitRequest()
528{
529 mOutputCommandThread->volRangeInitReqCommand();
530}
531
532void AudioPolicyService::doOnVolumeRangeInitRequest()
533{
534 Mutex::Autolock _l(mNotificationClientsLock);
535 for (size_t i = 0; i < mNotificationClients.size(); i++) {
536 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
537 }
538}
539
Eric Laurent81dd0f52021-07-05 11:54:40 +0200540void AudioPolicyService::onCheckSpatializer()
541{
542 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200543 onCheckSpatializer_l();
544}
545
546void AudioPolicyService::onCheckSpatializer_l()
547{
548 if (mSpatializer != nullptr) {
549 mOutputCommandThread->checkSpatializerCommand();
550 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200551}
552
553void AudioPolicyService::doOnCheckSpatializer()
554{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200555 ALOGV("%s mSpatializer %p level %d",
556 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200557
Eric Laurent39095982021-08-24 18:29:27 +0200558 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200559 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200560 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
561 audio_io_handle_t currentOutput = mSpatializer->getOutput();
562 audio_io_handle_t newOutput;
563 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
564 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200565
566 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200567 status_t status =
568 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100569 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
570 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200571 if (status == NO_ERROR && currentOutput == newOutput) {
572 return;
573 }
Eric Laurent15903592022-02-24 20:44:36 +0100574 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200575 mLock.unlock();
576 // It is OK to call detachOutput() is none is already attached.
577 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200578 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
579 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200580 }
Eric Laurent39095982021-08-24 18:29:27 +0200581 mLock.lock();
582 if (status != NO_ERROR) {
583 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
584 }
585 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
586 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200587 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200588
Eric Laurent39095982021-08-24 18:29:27 +0200589 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200590 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200591 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200592 }
593 }
594 }
595}
596
Eric Laurent11094172022-04-05 18:27:42 +0200597size_t AudioPolicyService::countActiveClientsOnOutput_l(
598 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100599 size_t count = 0;
600 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
601 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200602 if (client->io == output && client->active
603 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100604 count++;
605 }
606 }
607 return count;
608}
609
610void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
611 if (mSpatializer == nullptr) {
612 return;
613 }
614 mOutputCommandThread->updateActiveSpatializerTracksCommand();
615}
616
617void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
618{
Eric Laurent21270b62022-07-04 15:11:29 +0200619 if (mSpatializer == nullptr) {
620 return;
621 }
622 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200623 size_t activeClients;
624 {
625 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200626 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100627 }
Eric Laurent21270b62022-07-04 15:11:29 +0200628 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100629}
630
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800631status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
632 audio_patch_handle_t *handle,
633 int delayMs)
634{
635 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
636}
637
638status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
639 int delayMs)
640{
641 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
642}
643
Eric Laurente1715a42014-05-20 11:30:42 -0700644status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
645 int delayMs)
646{
647 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
648}
649
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800650AudioPolicyService::NotificationClient::NotificationClient(
651 const sp<AudioPolicyService>& service,
652 const sp<media::IAudioPolicyServiceClient>& client,
653 uid_t uid,
654 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800655 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100656 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700657{
658}
659
660AudioPolicyService::NotificationClient::~NotificationClient()
661{
662}
663
664void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
665{
666 sp<NotificationClient> keep(this);
667 sp<AudioPolicyService> service = mService.promote();
668 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800669 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700670 }
671}
672
673void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
674{
Eric Laurente8726fe2015-06-26 09:39:24 -0700675 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700676 mAudioPolicyServiceClient->onAudioPortListUpdate();
677 }
678}
679
680void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
681{
Eric Laurente8726fe2015-06-26 09:39:24 -0700682 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700683 mAudioPolicyServiceClient->onAudioPatchListUpdate();
684 }
685}
Eric Laurent57dae992011-07-24 13:36:09 -0700686
Pattydd807582021-11-04 21:01:03 +0800687void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100688 int flags)
689{
690 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
691 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
692 }
693}
694
695
Jean-Michel Trivide801052015-04-14 19:10:14 -0700696void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700697 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700698{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700699 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800700 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
701 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800702 }
703}
704
705void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800706 int event,
707 const record_client_info_t *clientInfo,
708 const audio_config_base_t *clientConfig,
709 std::vector<effect_descriptor_t> clientEffects,
710 const audio_config_base_t *deviceConfig,
711 std::vector<effect_descriptor_t> effects,
712 audio_patch_handle_t patchHandle,
713 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800714{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700715 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800716 status_t status = [&]() -> status_t {
717 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
718 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
719 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700720 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700721 legacy2aidl_audio_config_base_t_AudioConfigBase(
722 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800723 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
724 convertContainer<std::vector<media::EffectDescriptor>>(
725 clientEffects,
726 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700727 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700728 legacy2aidl_audio_config_base_t_AudioConfigBase(
729 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800730 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
731 convertContainer<std::vector<media::EffectDescriptor>>(
732 effects,
733 legacy2aidl_effect_descriptor_t_EffectDescriptor));
734 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
735 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700736 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
737 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800738 return aidl_utils::statusTFromBinderStatus(
739 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
740 clientInfoAidl,
741 clientConfigAidl,
742 clientEffectsAidl,
743 deviceConfigAidl,
744 effectsAidl,
745 patchHandleAidl,
746 sourceAidl));
747 }();
748 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700749 }
750}
751
Eric Laurente8726fe2015-06-26 09:39:24 -0700752void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
753{
754 mAudioPortCallbacksEnabled = enabled;
755}
756
François Gaffiecfe17322018-11-07 13:41:29 +0100757void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
758{
759 mAudioVolumeGroupCallbacksEnabled = enabled;
760}
Eric Laurente8726fe2015-06-26 09:39:24 -0700761
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700762void AudioPolicyService::NotificationClient::onRoutingUpdated()
763{
764 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
765 mAudioPolicyServiceClient->onRoutingUpdated();
766 }
767}
768
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000769void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
770{
771 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
772 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
773 }
774}
775
Mathias Agopian65ab4712010-07-14 17:59:35 -0700776void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700777 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700778 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700779}
780
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000781static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700782{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000783 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
784}
785
786static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
787{
788 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700789}
790
791status_t AudioPolicyService::dumpInternals(int fd)
792{
793 const size_t SIZE = 256;
794 char buffer[SIZE];
795 String8 result;
796
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000797 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800798 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000799 std::stringstream msg;
800 size_t i = 0;
801 for (auto usage : mSupportedSystemUsages) {
802 if (i++ != 0) msg << ", ";
803 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
804 msg << strUsage;
805 } else {
806 msg << usage << " (unknown)";
807 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800808 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000809 if (i == 0) {
810 msg << "None";
811 }
812 msg << std::endl;
813 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800814
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000815 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800816
817 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700818 return NO_ERROR;
819}
820
Eric Laurente8c8b432018-10-17 10:08:02 -0700821void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800822{
Eric Laurente8c8b432018-10-17 10:08:02 -0700823 Mutex::Autolock _l(mLock);
824 updateUidStates_l();
825}
826
827void AudioPolicyService::updateUidStates_l()
828{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800829// Go over all active clients and allow capture (does not force silence) in the
830// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800831// The client is in the active assistant list
832// AND is TOP
833// AND an accessibility service is TOP
834// AND source is either VOICE_RECOGNITION OR HOTWORD
835// OR there is no active privacy sensitive capture or call
836// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
837// AND source is VOICE_RECOGNITION OR HOTWORD
838// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800839// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700840// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800841// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800842// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800843// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
844// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800845// OR The client is an accessibility service
846// AND Is on TOP
847// AND the source is VOICE_RECOGNITION or HOTWORD
848// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700849// AND there is no active privacy sensitive capture or call
850// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800851// AND is on TOP
852// AND the source is VOICE_RECOGNITION or HOTWORD
853// OR the client source is virtual (remote submix, call audio TX or RX...)
854// OR the client source is HOTWORD
855// AND is on TOP
856// OR all active clients are using HOTWORD source
857// AND no call is active
858// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
859// OR the client is the current InputMethodService
860// AND a RTT call is active AND the source is VOICE_RECOGNITION
861// OR Any client
862// AND The assistant is not on TOP
863// AND is on TOP or latest started
864// AND there is no active privacy sensitive capture or call
865// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800866
Eric Laurent4e947da2019-10-17 15:24:06 -0700867
Eric Laurent4eb58f12018-12-07 16:41:02 -0800868 sp<AudioRecordClient> topActive;
869 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800870 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700871 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800872 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700873
Eric Laurenta46bedb2018-12-07 18:01:26 -0800874 nsecs_t topStartNs = 0;
875 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800876 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800877 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800878 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800879 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
880 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800881 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800882 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700883 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800884 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
885 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700886 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700887 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700888 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800889
Michael Groovercfd28302018-12-11 19:16:46 -0800890 // if Sensor Privacy is enabled then all recordings should be silenced.
891 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
892 silenceAllRecordings_l();
893 return;
894 }
895
Eric Laurente8c8b432018-10-17 10:08:02 -0700896 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
897 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000898 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
899 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800900 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700901 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800902 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700903
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700904 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700905 // clients which app is in IDLE state are not eligible for top active or
906 // latest active
907 if (appState == APP_STATE_IDLE) {
908 continue;
909 }
910
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700911 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700912 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800913 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700914 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700915 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800916 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800917 bool isPrivacySensitive =
918 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700919
Eric Laurentc21d5692020-02-25 10:24:36 -0800920 if (appState == APP_STATE_TOP) {
921 if (isPrivacySensitive) {
922 if (current->startTimeNs > topSensitiveStartNs) {
923 topSensitiveActive = current;
924 topSensitiveStartNs = current->startTimeNs;
925 }
926 } else {
927 if (current->startTimeNs > topStartNs) {
928 topActive = current;
929 topStartNs = current->startTimeNs;
930 }
931 }
932 if (isAssistant) {
933 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800934 if (isActiveAssistant) {
935 useActiveAssistantList = true;
936 } else if (!useActiveAssistantList) {
937 if (current->startTimeNs > latestAssistantStartNs) {
938 latestActiveAssistant = current;
939 latestAssistantStartNs = current->startTimeNs;
940 }
941 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800942 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800943 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800944 // Clients capturing for HOTWORD are not considered
945 // for latest active to avoid masking regular clients started before
946 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
947 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
948 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700949 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
950 // is marked latest sensitive active even if another app qualifies.
951 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700952 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700953 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700954 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000955 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700956 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700957 latestSensitiveActiveOrComm = current;
958 latestSensitiveStartNs = current->startTimeNs;
959 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800960 }
961 isSensitiveActive = true;
962 } else {
963 if (current->startTimeNs > latestStartNs) {
964 latestActive = current;
965 latestStartNs = current->startTimeNs;
966 }
967 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800968 }
969 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000970 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
971 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700972 onlyHotwordActive = false;
973 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100974 if (currentUid == mPhoneStateOwnerUid &&
975 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700976 isPhoneStateOwnerActive = true;
977 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800978 }
979
Eric Laurent1ff16a72019-03-14 18:35:04 -0700980 // if no active client with UI on Top, consider latest active as top
981 if (topActive == nullptr) {
982 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800983 topStartNs = latestStartNs;
984 }
985 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700986 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800987 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700988 } else if (latestSensitiveActiveOrComm != nullptr) {
989 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
990 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700991 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000992 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700993 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700994 topSensitiveActive = latestSensitiveActiveOrComm;
995 topSensitiveStartNs = latestSensitiveStartNs;
996 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800997 }
998
999 // If both privacy sensitive and regular capture are active:
1000 // if the regular capture is privileged
1001 // allow concurrency
1002 // else
1003 // favor the privacy sensitive case
1004 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001005 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001006 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001007 }
1008
1009 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1010 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001011 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001012 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001013 if (!current->active) {
1014 continue;
1015 }
1016
Eric Laurent4eb58f12018-12-07 16:41:02 -08001017 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001018 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001019 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001020 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001021 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001022 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1023 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001024
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001025 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001026 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001027 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001028 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001029 bool canCaptureCommunication = recordClient->canCaptureOutput
1030 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001031 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001032 return !(isInCall && !canCaptureCall)
1033 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001034 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001035
1036 // By default allow capture if:
1037 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001038 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001039 // AND there is no active privacy sensitive capture or call
1040 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001041 bool allowSensitiveCapture =
1042 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001043 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001044 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001045 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001046 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001047
Eric Laurented726cc2021-07-01 14:26:41 +02001048 if (!current->hasOp()) {
1049 // Never allow capture if app op is denied
1050 allowCapture = false;
1051 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001052 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1053 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001054 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001055 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001056 // Active assistant list is not being used
1057 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001058 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001059 // OR there is no active privacy sensitive capture or call
1060 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1061 // AND is latest TOP assistant AND
1062 // uses VOICE_RECOGNITION OR uses HOTWORD
1063 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001064 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001065 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001066 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001067 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001068 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001069 && canCaptureIfInCallOrCommunication(current)) {
1070 if (isTopOrLatestAssistant
1071 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1072 || source == AUDIO_SOURCE_HOTWORD)) {
1073 allowCapture = true;
1074 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1075 allowCapture = true;
1076 }
1077 }
1078 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1079 // For assistant on active list and on top allow capture if:
1080 // An accessibility service is on TOP
1081 // AND the source is VOICE_RECOGNITION or HOTWORD
1082 // OR there is no active privacy sensitive capture or call
1083 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1084 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1085 if (isA11yOnTop) {
1086 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1087 allowCapture = true;
1088 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001089 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001090 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001091 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1092 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001093 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001094 }
1095 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001096 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001097 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001098 // The assistant is not on TOP
1099 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001100 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001101 // OR
1102 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1103 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001104 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001105 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001106 allowCapture = true;
1107 }
Eric Laurent589171c2019-07-25 18:04:29 -07001108 if (isA11yOnTop) {
1109 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1110 allowCapture = true;
1111 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001112 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001113 } else if (source == AUDIO_SOURCE_HOTWORD) {
1114 // For HOTWORD source allow capture when not on TOP if:
1115 // All active clients are using HOTWORD source
1116 // AND no call is active
1117 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001118 if (onlyHotwordActive
1119 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001120 allowCapture = true;
1121 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001122 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001123 // For current InputMethodService allow capture if:
1124 // A RTT call is active AND the source is VOICE_RECOGNITION
1125 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1126 allowCapture = true;
1127 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001128 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001129 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001130 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001131 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001132 }
1133}
1134
Michael Groovercfd28302018-12-11 19:16:46 -08001135void AudioPolicyService::silenceAllRecordings_l() {
1136 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1137 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001138 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001139 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001140 }
Michael Groovercfd28302018-12-11 19:16:46 -08001141 }
1142}
1143
Eric Laurente8c8b432018-10-17 10:08:02 -07001144/* static */
1145app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001146
1147 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001148 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001149 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1150 // include persistent services
1151 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001152 }
1153 return APP_STATE_FOREGROUND;
1154}
1155
Eric Laurent4eb58f12018-12-07 16:41:02 -08001156/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001157bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001158{
1159 switch (source) {
1160 case AUDIO_SOURCE_VOICE_UPLINK:
1161 case AUDIO_SOURCE_VOICE_DOWNLINK:
1162 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001163 case AUDIO_SOURCE_REMOTE_SUBMIX:
1164 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001165 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001166 return true;
1167 default:
1168 break;
1169 }
1170 return false;
1171}
1172
Eric Laurent8c7ef892021-06-10 13:32:16 +02001173void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001174{
1175 AutoCallerClear acc;
1176
1177 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001178 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001179 }
1180 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1181 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001182 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001183 if (client->silenced != silenced) {
1184 if (client->active) {
1185 if (silenced) {
1186 finishRecording(client->attributionSource, client->attributes.source);
1187 } else {
1188 std::stringstream msg;
1189 msg << "Audio recording un-silenced on session " << client->session;
1190 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1191 client->attributes.source)) {
1192 silenced = true;
1193 }
1194 }
1195 }
1196 af->setRecordSilenced(client->portId, silenced);
1197 client->silenced = silenced;
1198 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001199 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001200}
1201
Glenn Kasten0f11b512014-01-31 16:18:54 -08001202status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001203{
Glenn Kasten44deb052012-02-05 18:09:08 -08001204 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001205 dumpPermissionDenial(fd);
1206 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001207 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001208 if (!locked) {
1209 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001210 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001211 }
1212
1213 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001214
1215 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001216 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001217 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001218 mAudioCommandThread->dump(fd);
1219 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001220
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001221 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001222 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001223 if (mOutputCommandThread != 0) {
1224 mOutputCommandThread->dump(fd);
1225 }
1226
Eric Laurentdce54a12014-03-10 12:19:46 -07001227 if (mAudioPolicyManager) {
1228 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001229 } else {
1230 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001231 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001232 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001233
Kevin Rocard8be94972019-02-22 13:26:25 -08001234 mPackageManager.dump(fd);
1235
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001236 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001237
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001238 if (mSpatializer != nullptr) {
1239 std::string dumpString = mSpatializer->toString(1 /* level */);
1240 write(fd, dumpString.c_str(), dumpString.size());
1241 } else {
1242 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1243 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1244 }
1245
Andy Hungc747c532022-03-07 21:41:14 -08001246 {
1247 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1248 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1249 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1250 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001251 }
1252 return NO_ERROR;
1253}
1254
1255status_t AudioPolicyService::dumpPermissionDenial(int fd)
1256{
1257 const size_t SIZE = 256;
1258 char buffer[SIZE];
1259 String8 result;
1260 snprintf(buffer, SIZE, "Permission Denial: "
1261 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1262 IPCThreadState::self()->getCallingPid(),
1263 IPCThreadState::self()->getCallingUid());
1264 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001265 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001266 return NO_ERROR;
1267}
1268
1269status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001270 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001271 // make sure transactions reserved to AudioFlinger do not come from other processes
1272 switch (code) {
1273 case TRANSACTION_startOutput:
1274 case TRANSACTION_stopOutput:
1275 case TRANSACTION_releaseOutput:
1276 case TRANSACTION_getInputForAttr:
1277 case TRANSACTION_startInput:
1278 case TRANSACTION_stopInput:
1279 case TRANSACTION_releaseInput:
1280 case TRANSACTION_getOutputForEffect:
1281 case TRANSACTION_registerEffect:
1282 case TRANSACTION_unregisterEffect:
1283 case TRANSACTION_setEffectEnabled:
1284 case TRANSACTION_getStrategyForStream:
1285 case TRANSACTION_getOutputForAttr:
1286 case TRANSACTION_moveEffectsToIo:
1287 ALOGW("%s: transaction %d received from PID %d",
1288 __func__, code, IPCThreadState::self()->getCallingPid());
1289 return INVALID_OPERATION;
1290 default:
1291 break;
1292 }
1293
1294 // make sure the following transactions come from system components
1295 switch (code) {
1296 case TRANSACTION_setDeviceConnectionState:
1297 case TRANSACTION_handleDeviceConfigChange:
1298 case TRANSACTION_setPhoneState:
1299//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1300// case TRANSACTION_setForceUse:
1301 case TRANSACTION_initStreamVolume:
1302 case TRANSACTION_setStreamVolumeIndex:
1303 case TRANSACTION_setVolumeIndexForAttributes:
1304 case TRANSACTION_getStreamVolumeIndex:
1305 case TRANSACTION_getVolumeIndexForAttributes:
1306 case TRANSACTION_getMinVolumeIndexForAttributes:
1307 case TRANSACTION_getMaxVolumeIndexForAttributes:
1308 case TRANSACTION_isStreamActive:
1309 case TRANSACTION_isStreamActiveRemotely:
1310 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001311 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001312 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001313 case TRANSACTION_setMasterMono:
1314 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001315 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001316 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001317 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001318 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001319 case TRANSACTION_setA11yServicesUids:
1320 case TRANSACTION_setUidDeviceAffinities:
1321 case TRANSACTION_removeUidDeviceAffinities:
1322 case TRANSACTION_setUserIdDeviceAffinities:
1323 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001324 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001325 case TRANSACTION_listAudioVolumeGroups:
1326 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1327 case TRANSACTION_acquireSoundTriggerSession:
1328 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001329 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001330 case TRANSACTION_setRttEnabled:
1331 case TRANSACTION_isCallScreenModeSupported:
1332 case TRANSACTION_setDevicesRoleForStrategy:
1333 case TRANSACTION_setSupportedSystemUsages:
1334 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001335 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001336 case TRANSACTION_getDevicesForRoleAndStrategy:
1337 case TRANSACTION_getDevicesForAttributes:
1338 case TRANSACTION_setAllowedCapturePolicy:
1339 case TRANSACTION_onNewAudioModulesAvailable:
1340 case TRANSACTION_setCurrentImeUid:
1341 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1342 case TRANSACTION_setDevicesRoleForCapturePreset:
1343 case TRANSACTION_addDevicesRoleForCapturePreset:
1344 case TRANSACTION_removeDevicesRoleForCapturePreset:
1345 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001346 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001347 case TRANSACTION_getSpatializer:
1348 case TRANSACTION_setPreferredMixerAttributes:
1349 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001350 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1351 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1352 __func__, code, IPCThreadState::self()->getCallingPid(),
1353 IPCThreadState::self()->getCallingUid());
1354 return INVALID_OPERATION;
1355 }
1356 } break;
1357 default:
1358 break;
1359 }
1360
Andy Hungc747c532022-03-07 21:41:14 -08001361 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1362 mediautils::TimeCheck check(
1363 std::string("IAudioPolicyService::").append(methodName),
1364 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1365 if (timeout) {
1366 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1367 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1368 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1369 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1370 .record();
1371 } else {
1372 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1373 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001374 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1375 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1376 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001377
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001378 switch (code) {
1379 case SHELL_COMMAND_TRANSACTION: {
1380 int in = data.readFileDescriptor();
1381 int out = data.readFileDescriptor();
1382 int err = data.readFileDescriptor();
1383 int argc = data.readInt32();
1384 Vector<String16> args;
1385 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1386 args.add(data.readString16());
1387 }
1388 sp<IBinder> unusedCallback;
1389 sp<IResultReceiver> resultReceiver;
1390 status_t status;
1391 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1392 return status;
1393 }
1394 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1395 return status;
1396 }
1397 status = shellCommand(in, out, err, args);
1398 if (resultReceiver != nullptr) {
1399 resultReceiver->send(status);
1400 }
1401 return NO_ERROR;
1402 }
1403 }
1404
Mathias Agopian65ab4712010-07-14 17:59:35 -07001405 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1406}
1407
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001408// ------------------- Shell command implementation -------------------
1409
1410// NOTE: This is a remote API - make sure all args are validated
1411status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1412 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1413 return PERMISSION_DENIED;
1414 }
1415 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1416 return BAD_VALUE;
1417 }
jovanakbe066e12019-09-02 11:54:39 -07001418 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001419 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001420 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001421 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001422 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001423 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001424 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1425 purgePermissionCache();
1426 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001427 } else if (args.size() == 1 && args[0] == String16("help")) {
1428 printHelp(out);
1429 return NO_ERROR;
1430 }
1431 printHelp(err);
1432 return BAD_VALUE;
1433}
1434
jovanakbe066e12019-09-02 11:54:39 -07001435static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1436 if (userId < 0) {
1437 ALOGE("Invalid user: %d", userId);
1438 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001439 return BAD_VALUE;
1440 }
jovanakbe066e12019-09-02 11:54:39 -07001441
1442 PermissionController pc;
1443 uid = pc.getPackageUid(packageName, 0);
1444 if (uid <= 0) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001445 ALOGE("Unknown package: '%s'", String8(packageName).c_str());
1446 dprintf(err, "Unknown package: '%s'\n", String8(packageName).c_str());
jovanakbe066e12019-09-02 11:54:39 -07001447 return BAD_VALUE;
1448 }
1449
1450 uid = multiuser_get_uid(userId, uid);
1451 return NO_ERROR;
1452}
1453
1454status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1455 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1456 if (!(args.size() == 3 || args.size() == 5)) {
1457 printHelp(err);
1458 return BAD_VALUE;
1459 }
1460
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001461 bool active = false;
1462 if (args[2] == String16("active")) {
1463 active = true;
1464 } else if ((args[2] != String16("idle"))) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001465 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).c_str());
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001466 return BAD_VALUE;
1467 }
jovanakbe066e12019-09-02 11:54:39 -07001468
1469 int userId = 0;
1470 if (args.size() >= 5 && args[3] == String16("--user")) {
1471 userId = atoi(String8(args[4]));
1472 }
1473
1474 uid_t uid;
1475 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1476 return BAD_VALUE;
1477 }
1478
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001479 sp<UidPolicy> uidPolicy;
1480 {
1481 Mutex::Autolock _l(mLock);
1482 uidPolicy = mUidPolicy;
1483 }
1484 if (uidPolicy) {
1485 uidPolicy->addOverrideUid(uid, active);
1486 return NO_ERROR;
1487 }
1488 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001489}
1490
1491status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001492 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1493 if (!(args.size() == 2 || args.size() == 4)) {
1494 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001495 return BAD_VALUE;
1496 }
jovanakbe066e12019-09-02 11:54:39 -07001497
1498 int userId = 0;
1499 if (args.size() >= 4 && args[2] == String16("--user")) {
1500 userId = atoi(String8(args[3]));
1501 }
1502
1503 uid_t uid;
1504 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1505 return BAD_VALUE;
1506 }
1507
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001508 sp<UidPolicy> uidPolicy;
1509 {
1510 Mutex::Autolock _l(mLock);
1511 uidPolicy = mUidPolicy;
1512 }
1513 if (uidPolicy) {
1514 uidPolicy->removeOverrideUid(uid);
1515 return NO_ERROR;
1516 }
1517 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001518}
1519
1520status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001521 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1522 if (!(args.size() == 2 || args.size() == 4)) {
1523 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001524 return BAD_VALUE;
1525 }
jovanakbe066e12019-09-02 11:54:39 -07001526
1527 int userId = 0;
1528 if (args.size() >= 4 && args[2] == String16("--user")) {
1529 userId = atoi(String8(args[3]));
1530 }
1531
1532 uid_t uid;
1533 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1534 return BAD_VALUE;
1535 }
1536
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001537 sp<UidPolicy> uidPolicy;
1538 {
1539 Mutex::Autolock _l(mLock);
1540 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001541 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001542 if (uidPolicy) {
1543 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1544 }
1545 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001546}
1547
1548status_t AudioPolicyService::printHelp(int out) {
1549 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001550 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1551 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1552 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001553 " help print this message\n");
1554}
1555
Eric Laurent0d13fea2022-11-04 17:12:08 +01001556status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1557 const audio_config_base_t& config,
1558 const audio_output_flags_t flags) {
1559 return mUsecaseValidator->registerStream(output, config, flags);
1560}
1561
1562status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1563 return mUsecaseValidator->unregisterStream(output);
1564}
1565
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001566// ----------- AudioPolicyService::UidPolicy implementation ----------
1567
1568void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001569 status_t res = mAm.linkToDeath(this);
1570 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001571 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001572 | ActivityManager::UID_OBSERVER_ACTIVE
1573 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001574 ActivityManager::PROCESS_STATE_UNKNOWN,
1575 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001576 if (!res) {
1577 Mutex::Autolock _l(mLock);
1578 mObserverRegistered = true;
1579 } else {
1580 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001581
Steven Moreland2f348142019-07-02 15:59:07 -07001582 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001583 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001584}
1585
1586void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001587 mAm.unlinkToDeath(this);
1588 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001589 Mutex::Autolock _l(mLock);
1590 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001591}
1592
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001593void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1594 Mutex::Autolock _l(mLock);
1595 mCachedUids.clear();
1596 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001597}
1598
Eric Laurente8c8b432018-10-17 10:08:02 -07001599void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001600 bool needToReregister = false;
1601 {
1602 Mutex::Autolock _l(mLock);
1603 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001604 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001605 if (needToReregister) {
1606 // Looks like ActivityManager has died previously, attempt to re-register.
1607 registerSelf();
1608 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001609}
1610
1611bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1612 if (isServiceUid(uid)) return true;
1613 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001614 {
1615 Mutex::Autolock _l(mLock);
1616 auto overrideIter = mOverrideUids.find(uid);
1617 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001618 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001619 }
1620 // In an absense of the ActivityManager, assume everything to be active.
1621 if (!mObserverRegistered) return true;
1622 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001623 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001624 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001625 }
1626 }
1627 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001628 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001629 {
1630 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001631 mCachedUids.insert(std::pair<uid_t,
1632 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1633 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001634 }
1635 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001636}
1637
Eric Laurente8c8b432018-10-17 10:08:02 -07001638int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1639 if (isServiceUid(uid)) {
1640 return ActivityManager::PROCESS_STATE_TOP;
1641 }
1642 checkRegistered();
1643 {
1644 Mutex::Autolock _l(mLock);
1645 auto overrideIter = mOverrideUids.find(uid);
1646 if (overrideIter != mOverrideUids.end()) {
1647 if (overrideIter->second.first) {
1648 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1649 return overrideIter->second.second;
1650 } else {
1651 auto cacheIter = mCachedUids.find(uid);
1652 if (cacheIter != mCachedUids.end()) {
1653 return cacheIter->second.second;
1654 }
1655 }
1656 }
1657 return ActivityManager::PROCESS_STATE_UNKNOWN;
1658 }
1659 // In an absense of the ActivityManager, assume everything to be active.
1660 if (!mObserverRegistered) {
1661 return ActivityManager::PROCESS_STATE_TOP;
1662 }
1663 auto cacheIter = mCachedUids.find(uid);
1664 if (cacheIter != mCachedUids.end()) {
1665 if (cacheIter->second.first) {
1666 return cacheIter->second.second;
1667 } else {
1668 return ActivityManager::PROCESS_STATE_UNKNOWN;
1669 }
1670 }
1671 }
1672 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001673 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001674 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1675 if (active) {
1676 state = am.getUidProcessState(uid, String16("audioserver"));
1677 }
1678 {
1679 Mutex::Autolock _l(mLock);
1680 mCachedUids.insert(std::pair<uid_t,
1681 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1682 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001683
Eric Laurente8c8b432018-10-17 10:08:02 -07001684 return state;
1685}
1686
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001687void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001688 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001689}
1690
1691void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001692 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001693}
1694
1695void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001696 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001697}
1698
Eric Laurente8c8b432018-10-17 10:08:02 -07001699void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1700 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001701 int64_t procStateSeq __unused,
1702 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001703 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1704 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001705 }
1706}
1707
Austin Borgerdddb7552023-03-30 17:53:01 -07001708void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001709}
1710
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001711void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001712 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1713}
1714
1715void AudioPolicyService::UidPolicy::notifyService() {
1716 sp<AudioPolicyService> service = mService.promote();
1717 if (service != nullptr) {
1718 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001719 }
1720}
1721
Eric Laurente8c8b432018-10-17 10:08:02 -07001722void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1723 std::pair<bool, int>> *uids,
1724 uid_t uid,
1725 bool active,
1726 int state,
1727 bool insert) {
1728 if (isServiceUid(uid)) {
1729 return;
1730 }
1731 bool wasActive = isUidActive(uid);
1732 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001733 {
1734 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001735 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001736 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001737 if (wasActive != isUidActive(uid) || state != previousState) {
1738 notifyService();
1739 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001740}
1741
Eric Laurente8c8b432018-10-17 10:08:02 -07001742void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1743 std::pair<bool, int>> *uids,
1744 uid_t uid,
1745 bool active,
1746 int state,
1747 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001748 auto it = uids->find(uid);
1749 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001750 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001751 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1752 it->second.first = active;
1753 }
1754 if (it->second.first) {
1755 it->second.second = state;
1756 } else {
1757 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1758 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001759 } else {
1760 uids->erase(it);
1761 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001762 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1763 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1764 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001765 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001766}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001767
Eric Laurent4eb58f12018-12-07 16:41:02 -08001768bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001769 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001770 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001771 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001772 continue;
1773 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001774 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1775 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001776 return true;
1777 }
1778 }
1779 return false;
1780}
1781
Eric Laurentb78763e2018-10-17 10:08:02 -07001782bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1783{
1784 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1785 return it != mA11yUids.end();
1786}
1787
Oscar Azucena829d90d2022-01-28 17:17:56 -08001788void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1789 mAssistantUids.clear();
1790 mAssistantUids = uids;
1791}
1792
1793bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1794{
1795 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1796 return it != mAssistantUids.end();
1797}
1798
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001799void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1800 mActiveAssistantUids = activeUids;
1801}
1802
1803bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1804{
1805 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1806 mActiveAssistantUids.end(), uid);
1807 return it != mActiveAssistantUids.end();
1808}
1809
Oscar Azucena829d90d2022-01-28 17:17:56 -08001810void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1811 const size_t SIZE = 256;
1812 char buffer[SIZE];
1813 String8 result;
1814 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1815 snprintf(buffer, SIZE, "\t%s: \n", title);
1816 result.append(buffer);
1817 int counter = 0;
1818 if (uids.empty()) {
1819 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1820 result.append(buffer);
1821 return;
1822 }
1823 for (const auto &uid : uids) {
1824 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1825 result.append(buffer);
1826 }
1827 };
1828
1829 snprintf(buffer, SIZE, "UID Policy:\n");
1830 result.append(buffer);
1831 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1832 result.append(buffer);
1833
1834 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001835 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001836
1837 appendUidsToResult("Accessibility UIDs", mA11yUids);
1838
1839 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1840 result.append(buffer);
1841
1842 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1843 result.append(buffer);
1844
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001845 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001846}
1847
Michael Groovercfd28302018-12-11 19:16:46 -08001848// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1849void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1850 SensorPrivacyManager spm;
1851 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1852 spm.addSensorPrivacyListener(this);
1853}
1854
1855void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1856 SensorPrivacyManager spm;
1857 spm.removeSensorPrivacyListener(this);
1858}
1859
1860bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1861 return mSensorPrivacyEnabled;
1862}
1863
Evan Seversond8dc6832022-01-27 10:47:03 -08001864binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1865 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001866 mSensorPrivacyEnabled = enabled;
1867 sp<AudioPolicyService> service = mService.promote();
1868 if (service != nullptr) {
1869 service->updateUidStates();
1870 }
1871 return binder::Status::ok();
1872}
1873
Mathias Agopian65ab4712010-07-14 17:59:35 -07001874// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1875
Eric Laurentbfb1b832013-01-07 09:53:42 -08001876AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1877 const wp<AudioPolicyService>& service)
1878 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001879{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001880}
1881
1882
1883AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1884{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001885 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001886 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001887 }
1888 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001889}
1890
1891void AudioPolicyService::AudioCommandThread::onFirstRef()
1892{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001893 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001894}
1895
1896bool AudioPolicyService::AudioCommandThread::threadLoop()
1897{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001898 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001899
1900 mLock.lock();
1901 while (!exitPending())
1902 {
Eric Laurent59a89232014-06-08 14:14:17 -07001903 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001904 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001905 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001906 nsecs_t curTime = systemTime();
1907 // commands are sorted by increasing time stamp: execute them from index 0 and up
1908 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001909 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001910 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001911 if (mAudioCommands.isEmpty()) {
1912 ++numTimesBecameEmpty;
1913 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001914 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001915
1916 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001917 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001918 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001919 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001920 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001921 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001922 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1923 data->mVolume,
1924 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001925 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001926 }break;
1927 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001928 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001929 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001930 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001931 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001932 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07001933 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001934 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001935 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001936 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001937 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001938 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07001939 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001940 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07001941 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001942 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001943 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001944 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001945 ALOGV("AudioCommandThread() processing stop output portId %d",
1946 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001947 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001948 if (svc == 0) {
1949 break;
1950 }
1951 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001952 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001953 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001954 }break;
1955 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001956 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001957 ALOGV("AudioCommandThread() processing release output portId %d",
1958 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001959 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001960 if (svc == 0) {
1961 break;
1962 }
1963 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001964 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001965 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001966 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001967 case CREATE_AUDIO_PATCH: {
1968 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1969 ALOGV("AudioCommandThread() processing create audio patch");
1970 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1971 if (af == 0) {
1972 command->mStatus = PERMISSION_DENIED;
1973 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07001974 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001975 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07001976 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001977 }
1978 } break;
1979 case RELEASE_AUDIO_PATCH: {
1980 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1981 ALOGV("AudioCommandThread() processing release audio patch");
1982 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1983 if (af == 0) {
1984 command->mStatus = PERMISSION_DENIED;
1985 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07001986 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001987 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07001988 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001989 }
1990 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001991 case UPDATE_AUDIOPORT_LIST: {
1992 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001993 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001994 if (svc == 0) {
1995 break;
1996 }
1997 mLock.unlock();
1998 svc->doOnAudioPortListUpdate();
1999 mLock.lock();
2000 }break;
2001 case UPDATE_AUDIOPATCH_LIST: {
2002 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002003 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002004 if (svc == 0) {
2005 break;
2006 }
2007 mLock.unlock();
2008 svc->doOnAudioPatchListUpdate();
2009 mLock.lock();
2010 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002011 case CHANGED_AUDIOVOLUMEGROUP: {
2012 AudioVolumeGroupData *data =
2013 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2014 ALOGV("AudioCommandThread() processing update audio volume group");
2015 svc = mService.promote();
2016 if (svc == 0) {
2017 break;
2018 }
2019 mLock.unlock();
2020 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2021 mLock.lock();
2022 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002023 case SET_AUDIOPORT_CONFIG: {
2024 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2025 ALOGV("AudioCommandThread() processing set port config");
2026 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2027 if (af == 0) {
2028 command->mStatus = PERMISSION_DENIED;
2029 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002030 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002031 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002032 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002033 }
2034 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002035 case DYN_POLICY_MIX_STATE_UPDATE: {
2036 DynPolicyMixStateUpdateData *data =
2037 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002038 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002039 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002040 svc = mService.promote();
2041 if (svc == 0) {
2042 break;
2043 }
2044 mLock.unlock();
2045 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2046 mLock.lock();
2047 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002048 case RECORDING_CONFIGURATION_UPDATE: {
2049 RecordingConfigurationUpdateData *data =
2050 (RecordingConfigurationUpdateData *)command->mParam.get();
2051 ALOGV("AudioCommandThread() processing recording configuration update");
2052 svc = mService.promote();
2053 if (svc == 0) {
2054 break;
2055 }
2056 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002057 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002058 &data->mClientConfig, data->mClientEffects,
2059 &data->mDeviceConfig, data->mEffects,
2060 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002061 mLock.lock();
2062 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002063 case SET_EFFECT_SUSPENDED: {
2064 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2065 ALOGV("AudioCommandThread() processing set effect suspended");
2066 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2067 if (af != 0) {
2068 mLock.unlock();
2069 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2070 mLock.lock();
2071 }
2072 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002073 case AUDIO_MODULES_UPDATE: {
2074 ALOGV("AudioCommandThread() processing audio modules update");
2075 svc = mService.promote();
2076 if (svc == 0) {
2077 break;
2078 }
2079 mLock.unlock();
2080 svc->doOnNewAudioModulesAvailable();
2081 mLock.lock();
2082 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002083 case ROUTING_UPDATED: {
2084 ALOGV("AudioCommandThread() processing routing update");
2085 svc = mService.promote();
2086 if (svc == 0) {
2087 break;
2088 }
2089 mLock.unlock();
2090 svc->doOnRoutingUpdated();
2091 mLock.lock();
2092 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002093
Eric Laurented726cc2021-07-01 14:26:41 +02002094 case UPDATE_UID_STATES: {
2095 ALOGV("AudioCommandThread() processing updateUID states");
2096 svc = mService.promote();
2097 if (svc == 0) {
2098 break;
2099 }
2100 mLock.unlock();
2101 svc->updateUidStates();
2102 mLock.lock();
2103 } break;
2104
Eric Laurent15903592022-02-24 20:44:36 +01002105 case CHECK_SPATIALIZER_OUTPUT: {
2106 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002107 svc = mService.promote();
2108 if (svc == 0) {
2109 break;
2110 }
2111 mLock.unlock();
2112 svc->doOnCheckSpatializer();
2113 mLock.lock();
2114 } break;
2115
Eric Laurent15903592022-02-24 20:44:36 +01002116 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2117 ALOGV("AudioCommandThread() processing update spatializer tracks");
2118 svc = mService.promote();
2119 if (svc == 0) {
2120 break;
2121 }
2122 mLock.unlock();
2123 svc->doOnUpdateActiveSpatializerTracks();
2124 mLock.lock();
2125 } break;
2126
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002127 case VOL_RANGE_INIT_REQUEST: {
2128 ALOGV("AudioCommandThread() processing volume range init request");
2129 svc = mService.promote();
2130 if (svc == 0) {
2131 break;
2132 }
2133 mLock.unlock();
2134 svc->doOnVolumeRangeInitRequest();
2135 mLock.lock();
2136 } break;
2137
Mathias Agopian65ab4712010-07-14 17:59:35 -07002138 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002139 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002140 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002141 {
2142 Mutex::Autolock _l(command->mLock);
2143 if (command->mWaitStatus) {
2144 command->mWaitStatus = false;
2145 command->mCond.signal();
2146 }
2147 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002148 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002149 // release mLock before releasing strong reference on the service as
2150 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2151 // acquires mLock.
2152 mLock.unlock();
2153 svc.clear();
2154 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002155 } else {
2156 waitTime = mAudioCommands[0]->mTime - curTime;
2157 break;
2158 }
2159 }
Zach Janga754b4f2015-10-27 01:29:34 +00002160
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002161 // release delayed commands wake lock as many times as we made the queue is
2162 // empty during popping.
2163 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002164 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002165 }
2166
2167 // At this stage we have either an empty command queue or the first command in the queue
2168 // has a finite delay. So unless we are exiting it is safe to wait.
2169 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002170 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002171 if (waitTime == -1) {
2172 mWaitWorkCV.wait(mLock);
2173 } else {
2174 mWaitWorkCV.waitRelative(mLock, waitTime);
2175 }
Eric Laurent59a89232014-06-08 14:14:17 -07002176 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002177 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002178 // release delayed commands wake lock before quitting
2179 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002180 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002181 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002182 mLock.unlock();
2183 return false;
2184}
2185
2186status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2187{
2188 const size_t SIZE = 256;
2189 char buffer[SIZE];
2190 String8 result;
2191
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002192 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002193 if (!locked) {
2194 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002195 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002196 }
2197
2198 snprintf(buffer, SIZE, "- Commands:\n");
2199 result = String8(buffer);
2200 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002201 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002202 mAudioCommands[i]->dump(buffer, SIZE);
2203 result.append(buffer);
2204 }
2205 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002206 if (mLastCommand != 0) {
2207 mLastCommand->dump(buffer, SIZE);
2208 result.append(buffer);
2209 } else {
2210 result.append(" none\n");
2211 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002212
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002213 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002214
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002215 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002216
2217 return NO_ERROR;
2218}
2219
Glenn Kastenfff6d712012-01-12 16:38:12 -08002220status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002221 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002222 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002223 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002224{
Eric Laurent0ede8922014-05-09 18:04:42 -07002225 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002226 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002227 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002228 data->mStream = stream;
2229 data->mVolume = volume;
2230 data->mIO = output;
2231 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002232 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002233 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002234 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002235 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002236}
2237
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002238status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002239 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002240 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002241{
Eric Laurent0ede8922014-05-09 18:04:42 -07002242 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002243 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002244 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002245 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002246 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002247 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002248 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002249 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002250 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002251 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002252}
2253
2254status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2255{
Eric Laurent0ede8922014-05-09 18:04:42 -07002256 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002257 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002258 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002259 data->mVolume = volume;
2260 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002261 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002262 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002263 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002264}
2265
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002266void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2267 audio_session_t sessionId,
2268 bool suspended)
2269{
2270 sp<AudioCommand> command = new AudioCommand();
2271 command->mCommand = SET_EFFECT_SUSPENDED;
2272 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2273 data->mEffectId = effectId;
2274 data->mSessionId = sessionId;
2275 data->mSuspended = suspended;
2276 command->mParam = data;
2277 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2278 effectId, sessionId, suspended);
2279 sendCommand(command);
2280}
2281
2282
Eric Laurentd7fe0862018-07-14 16:48:01 -07002283void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002284{
Eric Laurent0ede8922014-05-09 18:04:42 -07002285 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002286 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002287 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002288 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002289 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002290 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002291 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002292}
2293
Eric Laurentd7fe0862018-07-14 16:48:01 -07002294void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002295{
Eric Laurent0ede8922014-05-09 18:04:42 -07002296 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002297 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002298 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002299 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002300 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002301 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002302 sendCommand(command);
2303}
2304
Eric Laurent951f4552014-05-20 10:48:17 -07002305status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2306 const struct audio_patch *patch,
2307 audio_patch_handle_t *handle,
2308 int delayMs)
2309{
2310 status_t status = NO_ERROR;
2311
2312 sp<AudioCommand> command = new AudioCommand();
2313 command->mCommand = CREATE_AUDIO_PATCH;
2314 CreateAudioPatchData *data = new CreateAudioPatchData();
2315 data->mPatch = *patch;
2316 data->mHandle = *handle;
2317 command->mParam = data;
2318 command->mWaitStatus = true;
2319 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2320 status = sendCommand(command, delayMs);
2321 if (status == NO_ERROR) {
2322 *handle = data->mHandle;
2323 }
2324 return status;
2325}
2326
2327status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2328 int delayMs)
2329{
2330 sp<AudioCommand> command = new AudioCommand();
2331 command->mCommand = RELEASE_AUDIO_PATCH;
2332 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2333 data->mHandle = handle;
2334 command->mParam = data;
2335 command->mWaitStatus = true;
2336 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2337 return sendCommand(command, delayMs);
2338}
2339
Eric Laurentb52c1522014-05-20 11:27:36 -07002340void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2341{
2342 sp<AudioCommand> command = new AudioCommand();
2343 command->mCommand = UPDATE_AUDIOPORT_LIST;
2344 ALOGV("AudioCommandThread() adding update audio port list");
2345 sendCommand(command);
2346}
2347
Eric Laurented726cc2021-07-01 14:26:41 +02002348void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2349{
2350 sp<AudioCommand> command = new AudioCommand();
2351 command->mCommand = UPDATE_UID_STATES;
2352 ALOGV("AudioCommandThread() adding update UID states");
2353 sendCommand(command);
2354}
2355
Eric Laurentb52c1522014-05-20 11:27:36 -07002356void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2357{
2358 sp<AudioCommand>command = new AudioCommand();
2359 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2360 ALOGV("AudioCommandThread() adding update audio patch list");
2361 sendCommand(command);
2362}
2363
François Gaffiecfe17322018-11-07 13:41:29 +01002364void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2365 int flags)
2366{
2367 sp<AudioCommand>command = new AudioCommand();
2368 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2369 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2370 data->mGroup = group;
2371 data->mFlags = flags;
2372 command->mParam = data;
2373 ALOGV("AudioCommandThread() adding audio volume group changed");
2374 sendCommand(command);
2375}
2376
Eric Laurente1715a42014-05-20 11:30:42 -07002377status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2378 const struct audio_port_config *config, int delayMs)
2379{
2380 sp<AudioCommand> command = new AudioCommand();
2381 command->mCommand = SET_AUDIOPORT_CONFIG;
2382 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2383 data->mConfig = *config;
2384 command->mParam = data;
2385 command->mWaitStatus = true;
2386 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2387 return sendCommand(command, delayMs);
2388}
2389
Jean-Michel Trivide801052015-04-14 19:10:14 -07002390void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002391 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002392{
2393 sp<AudioCommand> command = new AudioCommand();
2394 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2395 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2396 data->mRegId = regId;
2397 data->mState = state;
2398 command->mParam = data;
2399 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002400 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002401 sendCommand(command);
2402}
2403
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002404void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002405 int event,
2406 const record_client_info_t *clientInfo,
2407 const audio_config_base_t *clientConfig,
2408 std::vector<effect_descriptor_t> clientEffects,
2409 const audio_config_base_t *deviceConfig,
2410 std::vector<effect_descriptor_t> effects,
2411 audio_patch_handle_t patchHandle,
2412 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002413{
2414 sp<AudioCommand>command = new AudioCommand();
2415 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2416 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2417 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002418 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002419 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002420 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002421 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002422 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002423 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002424 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002425 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002426 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2427 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002428 sendCommand(command);
2429}
2430
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002431void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2432{
2433 sp<AudioCommand> command = new AudioCommand();
2434 command->mCommand = AUDIO_MODULES_UPDATE;
2435 sendCommand(command);
2436}
2437
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002438void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2439{
2440 sp<AudioCommand>command = new AudioCommand();
2441 command->mCommand = ROUTING_UPDATED;
2442 ALOGV("AudioCommandThread() adding routing update");
2443 sendCommand(command);
2444}
2445
Eric Laurent81dd0f52021-07-05 11:54:40 +02002446void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2447{
2448 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002449 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002450 ALOGV("AudioCommandThread() adding check spatializer");
2451 sendCommand(command);
2452}
2453
Eric Laurent15903592022-02-24 20:44:36 +01002454void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2455{
2456 sp<AudioCommand>command = new AudioCommand();
2457 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2458 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2459 sendCommand(command);
2460}
2461
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002462void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2463{
2464 sp<AudioCommand>command = new AudioCommand();
2465 command->mCommand = VOL_RANGE_INIT_REQUEST;
2466 ALOGV("AudioCommandThread() adding volume range init request");
2467 sendCommand(command);
2468}
2469
Eric Laurent0ede8922014-05-09 18:04:42 -07002470status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2471{
2472 {
2473 Mutex::Autolock _l(mLock);
2474 insertCommand_l(command, delayMs);
2475 mWaitWorkCV.signal();
2476 }
2477 Mutex::Autolock _l(command->mLock);
2478 while (command->mWaitStatus) {
2479 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2480 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2481 command->mStatus = TIMED_OUT;
2482 command->mWaitStatus = false;
2483 }
2484 }
2485 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002486}
2487
Mathias Agopian65ab4712010-07-14 17:59:35 -07002488// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002489void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002490{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002491 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002492 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002493 command->mTime = systemTime() + milliseconds(delayMs);
2494
2495 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002496 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002497 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002498 }
2499
2500 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002501 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002502 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002503 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2504 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002505
2506 // create audio patch or release audio patch commands are equivalent
2507 // with regard to filtering
2508 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2509 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2510 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2511 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2512 continue;
2513 }
2514 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002515
2516 switch (command->mCommand) {
2517 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002518 ParametersData *data = (ParametersData *)command->mParam.get();
2519 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002520 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002521 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002522 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002523 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2524 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2525 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002526 String8 key;
2527 String8 value;
2528 param.getAt(j, key, value);
2529 for (size_t k = 0; k < param2.size(); k++) {
2530 String8 key2;
2531 String8 value2;
2532 param2.getAt(k, key2, value2);
2533 if (key2 == key) {
2534 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002535 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002536 break;
2537 }
2538 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002539 }
2540 // if all keys have been filtered out, remove the command.
2541 // otherwise, update the key value pairs
2542 if (param2.size() == 0) {
2543 removedCommands.add(command2);
2544 } else {
2545 data2->mKeyValuePairs = param2.toString();
2546 }
Eric Laurent21e54562013-09-23 12:08:05 -07002547 command->mTime = command2->mTime;
2548 // force delayMs to non 0 so that code below does not request to wait for
2549 // command status as the command is now delayed
2550 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002551 } break;
2552
2553 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002554 VolumeData *data = (VolumeData *)command->mParam.get();
2555 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002556 if (data->mIO != data2->mIO) break;
2557 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002558 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002559 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002560 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002561 command->mTime = command2->mTime;
2562 // force delayMs to non 0 so that code below does not request to wait for
2563 // command status as the command is now delayed
2564 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002565 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002566
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002567 case SET_VOICE_VOLUME: {
2568 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2569 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2570 ALOGV("Filtering out voice volume command value %f replaced by %f",
2571 data2->mVolume, data->mVolume);
2572 removedCommands.add(command2);
2573 command->mTime = command2->mTime;
2574 // force delayMs to non 0 so that code below does not request to wait for
2575 // command status as the command is now delayed
2576 delayMs = 1;
2577 } break;
2578
Eric Laurente45b48a2014-09-04 16:40:57 -07002579 case CREATE_AUDIO_PATCH:
2580 case RELEASE_AUDIO_PATCH: {
2581 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002582 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002583 if (command->mCommand == CREATE_AUDIO_PATCH) {
2584 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002585 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002586 } else {
2587 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002588 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002589 }
2590 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002591 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002592 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2593 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002594 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002595 } else {
2596 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002597 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002598 }
2599 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002600 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2601 same output. */
2602 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2603 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2604 bool isOutputDiff = false;
2605 if (patch.num_sources == patch2.num_sources) {
2606 for (unsigned count = 0; count < patch.num_sources; count++) {
2607 if (patch.sources[count].id != patch2.sources[count].id) {
2608 isOutputDiff = true;
2609 break;
2610 }
2611 }
2612 if (isOutputDiff)
2613 break;
2614 }
2615 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002616 ALOGV("Filtering out %s audio patch command for handle %d",
2617 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2618 removedCommands.add(command2);
2619 command->mTime = command2->mTime;
2620 // force delayMs to non 0 so that code below does not request to wait for
2621 // command status as the command is now delayed
2622 delayMs = 1;
2623 } break;
2624
Jean-Michel Trivide801052015-04-14 19:10:14 -07002625 case DYN_POLICY_MIX_STATE_UPDATE: {
2626
2627 } break;
2628
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002629 case RECORDING_CONFIGURATION_UPDATE: {
2630
2631 } break;
2632
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002633 case ROUTING_UPDATED: {
2634
2635 } break;
2636
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002637 case VOL_RANGE_INIT_REQUEST: {
2638 // command may come from different requests, do not filter
2639 } break;
2640
Mathias Agopian65ab4712010-07-14 17:59:35 -07002641 default:
2642 break;
2643 }
2644 }
2645
2646 // remove filtered commands
2647 for (size_t j = 0; j < removedCommands.size(); j++) {
2648 // removed commands always have time stamps greater than current command
2649 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002650 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002651 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002652 mAudioCommands.removeAt(k);
2653 break;
2654 }
2655 }
2656 }
2657 removedCommands.clear();
2658
Eric Laurentaa79bef2015-01-15 14:33:51 -08002659 // Disable wait for status if delay is not 0.
2660 // Except for create audio patch command because the returned patch handle
2661 // is needed by audio policy manager
2662 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002663 command->mWaitStatus = false;
2664 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002665
Mathias Agopian65ab4712010-07-14 17:59:35 -07002666 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002667 ALOGV("inserting command: %d at index %zd, num commands %zu",
2668 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002669 mAudioCommands.insertAt(command, i + 1);
2670}
2671
2672void AudioPolicyService::AudioCommandThread::exit()
2673{
Steve Block3856b092011-10-20 11:56:00 +01002674 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002675 {
2676 AutoMutex _l(mLock);
2677 requestExit();
2678 mWaitWorkCV.signal();
2679 }
Zach Janga754b4f2015-10-27 01:29:34 +00002680 // Note that we can call it from the thread loop if all other references have been released
2681 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002682 requestExitAndWait();
2683}
2684
2685void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2686{
2687 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2688 mCommand,
2689 (int)ns2s(mTime),
2690 (int)ns2ms(mTime)%1000,
2691 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002692 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002693}
2694
Dima Zavinfce7a472011-04-19 22:30:36 -07002695/******* helpers for the service_ops callbacks defined below *********/
2696void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2697 const char *keyValuePairs,
2698 int delayMs)
2699{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002700 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002701 delayMs);
2702}
2703
2704int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2705 float volume,
2706 audio_io_handle_t output,
2707 int delayMs)
2708{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002709 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002710 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002711}
2712
Dima Zavinfce7a472011-04-19 22:30:36 -07002713int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2714{
2715 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2716}
2717
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002718void AudioPolicyService::setEffectSuspended(int effectId,
2719 audio_session_t sessionId,
2720 bool suspended)
2721{
2722 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2723}
2724
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002725Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002726{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002727 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002728 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002729}
2730
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002731
Dima Zavinfce7a472011-04-19 22:30:36 -07002732extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002733audio_module_handle_t aps_load_hw_module(void *service __unused,
2734 const char *name);
2735audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002736 audio_devices_t *pDevices,
2737 uint32_t *pSamplingRate,
2738 audio_format_t *pFormat,
2739 audio_channel_mask_t *pChannelMask,
2740 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002741 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002742
Eric Laurent2d388ec2014-03-07 13:25:54 -08002743audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002744 audio_module_handle_t module,
2745 audio_devices_t *pDevices,
2746 uint32_t *pSamplingRate,
2747 audio_format_t *pFormat,
2748 audio_channel_mask_t *pChannelMask,
2749 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002750 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002751 const audio_offload_info_t *offloadInfo);
2752audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002753 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002754 audio_io_handle_t output2);
2755int aps_close_output(void *service __unused, audio_io_handle_t output);
2756int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2757int aps_restore_output(void *service __unused, audio_io_handle_t output);
2758audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002759 audio_devices_t *pDevices,
2760 uint32_t *pSamplingRate,
2761 audio_format_t *pFormat,
2762 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002763 audio_in_acoustics_t acoustics __unused);
2764audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002765 audio_module_handle_t module,
2766 audio_devices_t *pDevices,
2767 uint32_t *pSamplingRate,
2768 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002769 audio_channel_mask_t *pChannelMask);
2770int aps_close_input(void *service __unused, audio_io_handle_t input);
2771int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002772int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002773 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002774 audio_io_handle_t dst_output);
2775char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2776 const char *keys);
2777void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2778 const char *kv_pairs, int delay_ms);
2779int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002780 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002781 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002782int aps_set_voice_volume(void *service, float volume, int delay_ms);
2783};
Dima Zavinfce7a472011-04-19 22:30:36 -07002784
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002785} // namespace android