blob: c64113b3ad846fe235eeeef934ce1b8020b6e8cc [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) \
123BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
124BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
125BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
126BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
127BINDER_METHOD_ENTRY(startAudioSource) \
128BINDER_METHOD_ENTRY(stopAudioSource) \
129BINDER_METHOD_ENTRY(setMasterMono) \
130BINDER_METHOD_ENTRY(getMasterMono) \
131BINDER_METHOD_ENTRY(getStreamVolumeDB) \
132BINDER_METHOD_ENTRY(getSurroundFormats) \
133BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
134BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
135BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
136BINDER_METHOD_ENTRY(setAssistantServicesUids) \
137BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
138BINDER_METHOD_ENTRY(setA11yServicesUids) \
139BINDER_METHOD_ENTRY(setCurrentImeUid) \
140BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
141BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800142BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800143BINDER_METHOD_ENTRY(listAudioProductStrategies) \
144BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
145BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
146BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
147BINDER_METHOD_ENTRY(setRttEnabled) \
148BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
149BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
150BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000151BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800152BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
153BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
157BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
158BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
159BINDER_METHOD_ENTRY(getSpatializer) \
160BINDER_METHOD_ENTRY(canBeSpatialized) \
161BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000162BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
163BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
164BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
165BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
166BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800167
168// singleton for Binder Method Statistics for IAudioPolicyService
169static auto& getIAudioPolicyServiceStatistics() {
170 using Code = int;
171
172#pragma push_macro("BINDER_METHOD_ENTRY")
173#undef BINDER_METHOD_ENTRY
174#define BINDER_METHOD_ENTRY(ENTRY) \
175 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
176
177 static mediautils::MethodStatistics<Code> methodStatistics{
178 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
179 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
180 };
181#pragma pop_macro("BINDER_METHOD_ENTRY")
182
183 return methodStatistics;
184}
185
Mathias Agopian65ab4712010-07-14 17:59:35 -0700186// ----------------------------------------------------------------------------
187
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530188static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
189{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700190 AudioPolicyManager *apm = nullptr;
191 media::AudioPolicyConfig apmConfig;
192 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
193 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
194 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
195 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
196 "Only default engine is currently supported with the AIDL HAL");
197 apm = new AudioPolicyManager(config,
198 loadApmEngineLibraryAndCreateEngine(
199 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
200 clientInterface);
201 } else {
202 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
203 apm = new AudioPolicyManager(config,
204 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
205 clientInterface);
206 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530207 status_t status = apm->initialize();
208 if (status != NO_ERROR) {
209 delete apm;
210 apm = nullptr;
211 }
212 return apm;
213}
214
215static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
216{
217 delete interface;
218}
219// ----------------------------------------------------------------------------
220
Mathias Agopian65ab4712010-07-14 17:59:35 -0700221AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700222 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700223 mAudioPolicyManager(NULL),
224 mAudioPolicyClient(NULL),
225 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530226 mCaptureStateNotifier(false),
227 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100228 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
229 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800230 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530231}
232
233void AudioPolicyService::loadAudioPolicyManager()
234{
235 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
236 if (mLibraryHandle != nullptr) {
237 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
238 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
239 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
240 const char *lastError = dlerror();
241 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
242 __func__, lastError != nullptr ? lastError : "no error");
243
244 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
245 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
246 lastError = dlerror();
247 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
248 __func__, lastError != nullptr ? lastError : "no error");
249 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
250 unloadAudioPolicyManager();
251 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
252 }
253 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700254}
255
256void AudioPolicyService::onFirstRef()
257{
Andy Hungd47aca22022-03-15 11:50:51 -0700258 // Log an AudioPolicy "constructor" mediametrics event on first ref.
259 // This records the time it takes to load the audio modules and devices.
260 mediametrics::Defer defer([beginNs = systemTime()] {
261 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
262 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
263 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
264 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700265 {
266 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800267
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700268 // start audio commands thread
269 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
270 // start output activity command thread
271 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700272
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700273 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530274
275 loadAudioPolicyManager();
276 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700277 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200278
bryant_liuba2b4392014-06-11 16:49:30 +0800279 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000280 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
281 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects(effectsFactoryHal);
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000282 sp<UidPolicy> uidPolicy = new UidPolicy(this);
283 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700284 {
285 Mutex::Autolock _l(mLock);
286 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000287 mUidPolicy = uidPolicy;
288 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000290 uidPolicy->registerSelf();
291 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200292
Eric Laurent81dd0f52021-07-05 11:54:40 +0200293 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200294 if (mAudioPolicyManager != nullptr) {
295 Mutex::Autolock _l(mLock);
296 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
297 AudioDeviceTypeAddrVector devices;
298 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
299 if (hasSpatializer) {
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000300 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200301 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700302 if (mSpatializer == nullptr) {
303 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
304 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
305 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
306 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200307 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200308 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700309}
310
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530311void AudioPolicyService::unloadAudioPolicyManager()
312{
313 ALOGV("%s ", __func__);
314 if (mLibraryHandle != nullptr) {
315 dlclose(mLibraryHandle);
316 }
317 mLibraryHandle = nullptr;
318 mCreateAudioPolicyManager = nullptr;
319 mDestroyAudioPolicyManager = nullptr;
320}
321
Mathias Agopian65ab4712010-07-14 17:59:35 -0700322AudioPolicyService::~AudioPolicyService()
323{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700324 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700325 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700326
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530327 mDestroyAudioPolicyManager(mAudioPolicyManager);
328 unloadAudioPolicyManager();
329
Eric Laurentdce54a12014-03-10 12:19:46 -0700330 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700331
332 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800333 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800334
335 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800336 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000337
338 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800339 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700340}
341
342// A notification client is always registered by AudioSystem when the client process
343// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800344Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700345{
Eric Laurent12590252015-08-21 18:40:20 -0700346 if (client == 0) {
347 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800348 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700349 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800350 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700351
352 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800353 pid_t pid = IPCThreadState::self()->getCallingPid();
354 int64_t token = ((int64_t)uid<<32) | pid;
355
356 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700357 sp<NotificationClient> notificationClient = new NotificationClient(this,
358 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800359 uid,
360 pid);
361 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700362
luochaojiang908c7d72018-06-21 14:58:04 +0800363 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700364
Marco Nelissenf8880202014-11-14 07:58:25 -0800365 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700366 binder->linkToDeath(notificationClient);
367 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800368 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700369}
370
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800371Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700372{
373 Mutex::Autolock _l(mNotificationClientsLock);
374
375 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800376 pid_t pid = IPCThreadState::self()->getCallingPid();
377 int64_t token = ((int64_t)uid<<32) | pid;
378
379 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800380 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700381 }
luochaojiang908c7d72018-06-21 14:58:04 +0800382 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800383 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700384}
385
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800386Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100387{
388 Mutex::Autolock _l(mNotificationClientsLock);
389
390 uid_t uid = IPCThreadState::self()->getCallingUid();
391 pid_t pid = IPCThreadState::self()->getCallingPid();
392 int64_t token = ((int64_t)uid<<32) | pid;
393
394 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800395 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100396 }
397 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800398 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100399}
400
Eric Laurentb52c1522014-05-20 11:27:36 -0700401// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800402void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700403{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000404 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800405 {
406 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800407 int64_t token = ((int64_t)uid<<32) | pid;
408 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800409 for (size_t i = 0; i < mNotificationClients.size(); i++) {
410 if (mNotificationClients.valueAt(i)->uid() == uid) {
411 hasSameUid = true;
412 break;
413 }
414 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000415 }
416 {
417 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800418 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700419 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700420 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700421 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800422 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700423}
424
425void AudioPolicyService::onAudioPortListUpdate()
426{
427 mOutputCommandThread->updateAudioPortListCommand();
428}
429
430void AudioPolicyService::doOnAudioPortListUpdate()
431{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800432 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700433 for (size_t i = 0; i < mNotificationClients.size(); i++) {
434 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
435 }
436}
437
438void AudioPolicyService::onAudioPatchListUpdate()
439{
440 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700441}
442
Eric Laurentb52c1522014-05-20 11:27:36 -0700443void AudioPolicyService::doOnAudioPatchListUpdate()
444{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800445 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700446 for (size_t i = 0; i < mNotificationClients.size(); i++) {
447 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
448 }
449}
450
François Gaffiecfe17322018-11-07 13:41:29 +0100451void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
452{
453 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
454}
455
456void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
457{
458 Mutex::Autolock _l(mNotificationClientsLock);
459 for (size_t i = 0; i < mNotificationClients.size(); i++) {
460 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
461 }
462}
463
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700464void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700465{
466 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
467 regId.string(), state);
468 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
469}
470
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700471void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700472{
473 Mutex::Autolock _l(mNotificationClientsLock);
474 for (size_t i = 0; i < mNotificationClients.size(); i++) {
475 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
476 }
477}
478
Eric Laurenta9f86652018-11-28 17:23:11 -0800479void AudioPolicyService::onRecordingConfigurationUpdate(
480 int event,
481 const record_client_info_t *clientInfo,
482 const audio_config_base_t *clientConfig,
483 std::vector<effect_descriptor_t> clientEffects,
484 const audio_config_base_t *deviceConfig,
485 std::vector<effect_descriptor_t> effects,
486 audio_patch_handle_t patchHandle,
487 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800488{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800489 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800490 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800491}
492
Eric Laurenta9f86652018-11-28 17:23:11 -0800493void AudioPolicyService::doOnRecordingConfigurationUpdate(
494 int event,
495 const record_client_info_t *clientInfo,
496 const audio_config_base_t *clientConfig,
497 std::vector<effect_descriptor_t> clientEffects,
498 const audio_config_base_t *deviceConfig,
499 std::vector<effect_descriptor_t> effects,
500 audio_patch_handle_t patchHandle,
501 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800502{
503 Mutex::Autolock _l(mNotificationClientsLock);
504 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800505 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800506 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800507 }
508}
509
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700510void AudioPolicyService::onRoutingUpdated()
511{
512 mOutputCommandThread->routingChangedCommand();
513}
514
515void AudioPolicyService::doOnRoutingUpdated()
516{
517 Mutex::Autolock _l(mNotificationClientsLock);
518 for (size_t i = 0; i < mNotificationClients.size(); i++) {
519 mNotificationClients.valueAt(i)->onRoutingUpdated();
520 }
521}
522
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000523void AudioPolicyService::onVolumeRangeInitRequest()
524{
525 mOutputCommandThread->volRangeInitReqCommand();
526}
527
528void AudioPolicyService::doOnVolumeRangeInitRequest()
529{
530 Mutex::Autolock _l(mNotificationClientsLock);
531 for (size_t i = 0; i < mNotificationClients.size(); i++) {
532 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
533 }
534}
535
Eric Laurent81dd0f52021-07-05 11:54:40 +0200536void AudioPolicyService::onCheckSpatializer()
537{
538 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200539 onCheckSpatializer_l();
540}
541
542void AudioPolicyService::onCheckSpatializer_l()
543{
544 if (mSpatializer != nullptr) {
545 mOutputCommandThread->checkSpatializerCommand();
546 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200547}
548
549void AudioPolicyService::doOnCheckSpatializer()
550{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200551 ALOGV("%s mSpatializer %p level %d",
552 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200553
Eric Laurent39095982021-08-24 18:29:27 +0200554 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200555 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200556 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
557 audio_io_handle_t currentOutput = mSpatializer->getOutput();
558 audio_io_handle_t newOutput;
559 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
560 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200561
562 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200563 status_t status =
564 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100565 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
566 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200567 if (status == NO_ERROR && currentOutput == newOutput) {
568 return;
569 }
Eric Laurent15903592022-02-24 20:44:36 +0100570 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200571 mLock.unlock();
572 // It is OK to call detachOutput() is none is already attached.
573 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200574 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
575 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200576 }
Eric Laurent39095982021-08-24 18:29:27 +0200577 mLock.lock();
578 if (status != NO_ERROR) {
579 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
580 }
581 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
582 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200583 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200584
Eric Laurent39095982021-08-24 18:29:27 +0200585 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200586 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200587 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200588 }
589 }
590 }
591}
592
Eric Laurent11094172022-04-05 18:27:42 +0200593size_t AudioPolicyService::countActiveClientsOnOutput_l(
594 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100595 size_t count = 0;
596 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
597 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200598 if (client->io == output && client->active
599 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100600 count++;
601 }
602 }
603 return count;
604}
605
606void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
607 if (mSpatializer == nullptr) {
608 return;
609 }
610 mOutputCommandThread->updateActiveSpatializerTracksCommand();
611}
612
613void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
614{
Eric Laurent21270b62022-07-04 15:11:29 +0200615 if (mSpatializer == nullptr) {
616 return;
617 }
618 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200619 size_t activeClients;
620 {
621 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200622 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100623 }
Eric Laurent21270b62022-07-04 15:11:29 +0200624 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100625}
626
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800627status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
628 audio_patch_handle_t *handle,
629 int delayMs)
630{
631 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
632}
633
634status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
635 int delayMs)
636{
637 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
638}
639
Eric Laurente1715a42014-05-20 11:30:42 -0700640status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
641 int delayMs)
642{
643 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
644}
645
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800646AudioPolicyService::NotificationClient::NotificationClient(
647 const sp<AudioPolicyService>& service,
648 const sp<media::IAudioPolicyServiceClient>& client,
649 uid_t uid,
650 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800651 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100652 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700653{
654}
655
656AudioPolicyService::NotificationClient::~NotificationClient()
657{
658}
659
660void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
661{
662 sp<NotificationClient> keep(this);
663 sp<AudioPolicyService> service = mService.promote();
664 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800665 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700666 }
667}
668
669void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
670{
Eric Laurente8726fe2015-06-26 09:39:24 -0700671 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700672 mAudioPolicyServiceClient->onAudioPortListUpdate();
673 }
674}
675
676void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
677{
Eric Laurente8726fe2015-06-26 09:39:24 -0700678 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700679 mAudioPolicyServiceClient->onAudioPatchListUpdate();
680 }
681}
Eric Laurent57dae992011-07-24 13:36:09 -0700682
Pattydd807582021-11-04 21:01:03 +0800683void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100684 int flags)
685{
686 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
687 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
688 }
689}
690
691
Jean-Michel Trivide801052015-04-14 19:10:14 -0700692void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700693 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700694{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700695 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800696 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
697 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800698 }
699}
700
701void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800702 int event,
703 const record_client_info_t *clientInfo,
704 const audio_config_base_t *clientConfig,
705 std::vector<effect_descriptor_t> clientEffects,
706 const audio_config_base_t *deviceConfig,
707 std::vector<effect_descriptor_t> effects,
708 audio_patch_handle_t patchHandle,
709 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800710{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700711 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800712 status_t status = [&]() -> status_t {
713 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
714 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
715 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700716 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700717 legacy2aidl_audio_config_base_t_AudioConfigBase(
718 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800719 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
720 convertContainer<std::vector<media::EffectDescriptor>>(
721 clientEffects,
722 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700723 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700724 legacy2aidl_audio_config_base_t_AudioConfigBase(
725 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800726 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
727 convertContainer<std::vector<media::EffectDescriptor>>(
728 effects,
729 legacy2aidl_effect_descriptor_t_EffectDescriptor));
730 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
731 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700732 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
733 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800734 return aidl_utils::statusTFromBinderStatus(
735 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
736 clientInfoAidl,
737 clientConfigAidl,
738 clientEffectsAidl,
739 deviceConfigAidl,
740 effectsAidl,
741 patchHandleAidl,
742 sourceAidl));
743 }();
744 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700745 }
746}
747
Eric Laurente8726fe2015-06-26 09:39:24 -0700748void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
749{
750 mAudioPortCallbacksEnabled = enabled;
751}
752
François Gaffiecfe17322018-11-07 13:41:29 +0100753void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
754{
755 mAudioVolumeGroupCallbacksEnabled = enabled;
756}
Eric Laurente8726fe2015-06-26 09:39:24 -0700757
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700758void AudioPolicyService::NotificationClient::onRoutingUpdated()
759{
760 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
761 mAudioPolicyServiceClient->onRoutingUpdated();
762 }
763}
764
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000765void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
766{
767 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
768 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
769 }
770}
771
Mathias Agopian65ab4712010-07-14 17:59:35 -0700772void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700773 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700774 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700775}
776
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000777static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700778{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000779 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
780}
781
782static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
783{
784 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700785}
786
787status_t AudioPolicyService::dumpInternals(int fd)
788{
789 const size_t SIZE = 256;
790 char buffer[SIZE];
791 String8 result;
792
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000793 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800794 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000795 std::stringstream msg;
796 size_t i = 0;
797 for (auto usage : mSupportedSystemUsages) {
798 if (i++ != 0) msg << ", ";
799 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
800 msg << strUsage;
801 } else {
802 msg << usage << " (unknown)";
803 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800804 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000805 if (i == 0) {
806 msg << "None";
807 }
808 msg << std::endl;
809 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800810
Mathias Agopian65ab4712010-07-14 17:59:35 -0700811 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800812
813 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700814 return NO_ERROR;
815}
816
Eric Laurente8c8b432018-10-17 10:08:02 -0700817void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800818{
Eric Laurente8c8b432018-10-17 10:08:02 -0700819 Mutex::Autolock _l(mLock);
820 updateUidStates_l();
821}
822
823void AudioPolicyService::updateUidStates_l()
824{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800825// Go over all active clients and allow capture (does not force silence) in the
826// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800827// The client is in the active assistant list
828// AND is TOP
829// AND an accessibility service is TOP
830// AND source is either VOICE_RECOGNITION OR HOTWORD
831// OR there is no active privacy sensitive capture or call
832// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
833// AND source is VOICE_RECOGNITION OR HOTWORD
834// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800835// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700836// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800837// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800838// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800839// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
840// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800841// OR The client is an accessibility service
842// AND Is on TOP
843// AND the source is VOICE_RECOGNITION or HOTWORD
844// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700845// AND there is no active privacy sensitive capture or call
846// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800847// AND is on TOP
848// AND the source is VOICE_RECOGNITION or HOTWORD
849// OR the client source is virtual (remote submix, call audio TX or RX...)
850// OR the client source is HOTWORD
851// AND is on TOP
852// OR all active clients are using HOTWORD source
853// AND no call is active
854// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
855// OR the client is the current InputMethodService
856// AND a RTT call is active AND the source is VOICE_RECOGNITION
857// OR Any client
858// AND The assistant is not on TOP
859// AND is on TOP or latest started
860// AND there is no active privacy sensitive capture or call
861// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800862
Eric Laurent4e947da2019-10-17 15:24:06 -0700863
Eric Laurent4eb58f12018-12-07 16:41:02 -0800864 sp<AudioRecordClient> topActive;
865 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800866 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700867 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800868 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700869
Eric Laurenta46bedb2018-12-07 18:01:26 -0800870 nsecs_t topStartNs = 0;
871 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800872 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800873 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800874 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800875 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
876 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800877 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800878 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700879 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800880 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
881 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700882 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700883 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700884 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800885
Michael Groovercfd28302018-12-11 19:16:46 -0800886 // if Sensor Privacy is enabled then all recordings should be silenced.
887 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
888 silenceAllRecordings_l();
889 return;
890 }
891
Eric Laurente8c8b432018-10-17 10:08:02 -0700892 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
893 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000894 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
895 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800896 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700897 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800898 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700899
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700900 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700901 // clients which app is in IDLE state are not eligible for top active or
902 // latest active
903 if (appState == APP_STATE_IDLE) {
904 continue;
905 }
906
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700907 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700908 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800909 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700910 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700911 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800912 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800913 bool isPrivacySensitive =
914 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700915
Eric Laurentc21d5692020-02-25 10:24:36 -0800916 if (appState == APP_STATE_TOP) {
917 if (isPrivacySensitive) {
918 if (current->startTimeNs > topSensitiveStartNs) {
919 topSensitiveActive = current;
920 topSensitiveStartNs = current->startTimeNs;
921 }
922 } else {
923 if (current->startTimeNs > topStartNs) {
924 topActive = current;
925 topStartNs = current->startTimeNs;
926 }
927 }
928 if (isAssistant) {
929 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800930 if (isActiveAssistant) {
931 useActiveAssistantList = true;
932 } else if (!useActiveAssistantList) {
933 if (current->startTimeNs > latestAssistantStartNs) {
934 latestActiveAssistant = current;
935 latestAssistantStartNs = current->startTimeNs;
936 }
937 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800938 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800939 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800940 // Clients capturing for HOTWORD are not considered
941 // for latest active to avoid masking regular clients started before
942 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
943 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
944 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700945 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
946 // is marked latest sensitive active even if another app qualifies.
947 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700948 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700949 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700950 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000951 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700952 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700953 latestSensitiveActiveOrComm = current;
954 latestSensitiveStartNs = current->startTimeNs;
955 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800956 }
957 isSensitiveActive = true;
958 } else {
959 if (current->startTimeNs > latestStartNs) {
960 latestActive = current;
961 latestStartNs = current->startTimeNs;
962 }
963 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800964 }
965 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700966 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
967 onlyHotwordActive = false;
968 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100969 if (currentUid == mPhoneStateOwnerUid &&
970 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700971 isPhoneStateOwnerActive = true;
972 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800973 }
974
Eric Laurent1ff16a72019-03-14 18:35:04 -0700975 // if no active client with UI on Top, consider latest active as top
976 if (topActive == nullptr) {
977 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800978 topStartNs = latestStartNs;
979 }
980 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700981 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800982 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700983 } else if (latestSensitiveActiveOrComm != nullptr) {
984 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
985 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700986 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000987 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700988 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700989 topSensitiveActive = latestSensitiveActiveOrComm;
990 topSensitiveStartNs = latestSensitiveStartNs;
991 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800992 }
993
994 // If both privacy sensitive and regular capture are active:
995 // if the regular capture is privileged
996 // allow concurrency
997 // else
998 // favor the privacy sensitive case
999 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001000 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001001 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001002 }
1003
1004 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1005 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001006 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001007 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001008 if (!current->active) {
1009 continue;
1010 }
1011
Eric Laurent4eb58f12018-12-07 16:41:02 -08001012 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001013 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001014 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001015 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001016 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001017 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1018 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001019
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001020 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001021 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001022 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001023 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001024 bool canCaptureCommunication = recordClient->canCaptureOutput
1025 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001026 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001027 return !(isInCall && !canCaptureCall)
1028 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001029 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001030
1031 // By default allow capture if:
1032 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001033 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001034 // AND there is no active privacy sensitive capture or call
1035 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001036 bool allowSensitiveCapture =
1037 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001038 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001039 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001040 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001041 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001042
Eric Laurented726cc2021-07-01 14:26:41 +02001043 if (!current->hasOp()) {
1044 // Never allow capture if app op is denied
1045 allowCapture = false;
1046 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001047 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1048 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001049 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001050 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001051 // Active assistant list is not being used
1052 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001053 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001054 // OR there is no active privacy sensitive capture or call
1055 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1056 // AND is latest TOP assistant AND
1057 // uses VOICE_RECOGNITION OR uses HOTWORD
1058 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001059 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001060 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001061 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001062 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001063 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001064 && canCaptureIfInCallOrCommunication(current)) {
1065 if (isTopOrLatestAssistant
1066 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1067 || source == AUDIO_SOURCE_HOTWORD)) {
1068 allowCapture = true;
1069 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1070 allowCapture = true;
1071 }
1072 }
1073 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1074 // For assistant on active list and on top allow capture if:
1075 // An accessibility service is on TOP
1076 // AND the source is VOICE_RECOGNITION or HOTWORD
1077 // OR there is no active privacy sensitive capture or call
1078 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1079 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1080 if (isA11yOnTop) {
1081 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1082 allowCapture = true;
1083 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001084 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001085 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001086 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1087 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001088 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001089 }
1090 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001091 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001092 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001093 // The assistant is not on TOP
1094 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001095 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001096 // OR
1097 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1098 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001099 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001100 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001101 allowCapture = true;
1102 }
Eric Laurent589171c2019-07-25 18:04:29 -07001103 if (isA11yOnTop) {
1104 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1105 allowCapture = true;
1106 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001107 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001108 } else if (source == AUDIO_SOURCE_HOTWORD) {
1109 // For HOTWORD source allow capture when not on TOP if:
1110 // All active clients are using HOTWORD source
1111 // AND no call is active
1112 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001113 if (onlyHotwordActive
1114 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001115 allowCapture = true;
1116 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001117 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001118 // For current InputMethodService allow capture if:
1119 // A RTT call is active AND the source is VOICE_RECOGNITION
1120 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1121 allowCapture = true;
1122 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001123 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001124 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001125 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001126 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001127 }
1128}
1129
Michael Groovercfd28302018-12-11 19:16:46 -08001130void AudioPolicyService::silenceAllRecordings_l() {
1131 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1132 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001133 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001134 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001135 }
Michael Groovercfd28302018-12-11 19:16:46 -08001136 }
1137}
1138
Eric Laurente8c8b432018-10-17 10:08:02 -07001139/* static */
1140app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001141
1142 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001143 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001144 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1145 // include persistent services
1146 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001147 }
1148 return APP_STATE_FOREGROUND;
1149}
1150
Eric Laurent4eb58f12018-12-07 16:41:02 -08001151/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001152bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001153{
1154 switch (source) {
1155 case AUDIO_SOURCE_VOICE_UPLINK:
1156 case AUDIO_SOURCE_VOICE_DOWNLINK:
1157 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001158 case AUDIO_SOURCE_REMOTE_SUBMIX:
1159 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001160 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001161 return true;
1162 default:
1163 break;
1164 }
1165 return false;
1166}
1167
Eric Laurent8c7ef892021-06-10 13:32:16 +02001168void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001169{
1170 AutoCallerClear acc;
1171
1172 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001173 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001174 }
1175 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1176 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001177 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001178 if (client->silenced != silenced) {
1179 if (client->active) {
1180 if (silenced) {
1181 finishRecording(client->attributionSource, client->attributes.source);
1182 } else {
1183 std::stringstream msg;
1184 msg << "Audio recording un-silenced on session " << client->session;
1185 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1186 client->attributes.source)) {
1187 silenced = true;
1188 }
1189 }
1190 }
1191 af->setRecordSilenced(client->portId, silenced);
1192 client->silenced = silenced;
1193 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001194 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001195}
1196
Glenn Kasten0f11b512014-01-31 16:18:54 -08001197status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001198{
Glenn Kasten44deb052012-02-05 18:09:08 -08001199 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001200 dumpPermissionDenial(fd);
1201 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001202 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001203 if (!locked) {
1204 String8 result(kDeadlockedString);
1205 write(fd, result.string(), result.size());
1206 }
1207
1208 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001209
1210 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1211 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001212 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001213 mAudioCommandThread->dump(fd);
1214 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001216 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1217 write(fd, octPtr.string(), octPtr.size());
1218 if (mOutputCommandThread != 0) {
1219 mOutputCommandThread->dump(fd);
1220 }
1221
Eric Laurentdce54a12014-03-10 12:19:46 -07001222 if (mAudioPolicyManager) {
1223 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001224 } else {
1225 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1226 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001227 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001228
Kevin Rocard8be94972019-02-22 13:26:25 -08001229 mPackageManager.dump(fd);
1230
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001231 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001232
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001233 if (mSpatializer != nullptr) {
1234 std::string dumpString = mSpatializer->toString(1 /* level */);
1235 write(fd, dumpString.c_str(), dumpString.size());
1236 } else {
1237 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1238 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1239 }
1240
Andy Hungc747c532022-03-07 21:41:14 -08001241 {
1242 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1243 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1244 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1245 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001246 }
1247 return NO_ERROR;
1248}
1249
1250status_t AudioPolicyService::dumpPermissionDenial(int fd)
1251{
1252 const size_t SIZE = 256;
1253 char buffer[SIZE];
1254 String8 result;
1255 snprintf(buffer, SIZE, "Permission Denial: "
1256 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1257 IPCThreadState::self()->getCallingPid(),
1258 IPCThreadState::self()->getCallingUid());
1259 result.append(buffer);
1260 write(fd, result.string(), result.size());
1261 return NO_ERROR;
1262}
1263
1264status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001265 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001266 // make sure transactions reserved to AudioFlinger do not come from other processes
1267 switch (code) {
1268 case TRANSACTION_startOutput:
1269 case TRANSACTION_stopOutput:
1270 case TRANSACTION_releaseOutput:
1271 case TRANSACTION_getInputForAttr:
1272 case TRANSACTION_startInput:
1273 case TRANSACTION_stopInput:
1274 case TRANSACTION_releaseInput:
1275 case TRANSACTION_getOutputForEffect:
1276 case TRANSACTION_registerEffect:
1277 case TRANSACTION_unregisterEffect:
1278 case TRANSACTION_setEffectEnabled:
1279 case TRANSACTION_getStrategyForStream:
1280 case TRANSACTION_getOutputForAttr:
1281 case TRANSACTION_moveEffectsToIo:
1282 ALOGW("%s: transaction %d received from PID %d",
1283 __func__, code, IPCThreadState::self()->getCallingPid());
1284 return INVALID_OPERATION;
1285 default:
1286 break;
1287 }
1288
1289 // make sure the following transactions come from system components
1290 switch (code) {
1291 case TRANSACTION_setDeviceConnectionState:
1292 case TRANSACTION_handleDeviceConfigChange:
1293 case TRANSACTION_setPhoneState:
1294//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1295// case TRANSACTION_setForceUse:
1296 case TRANSACTION_initStreamVolume:
1297 case TRANSACTION_setStreamVolumeIndex:
1298 case TRANSACTION_setVolumeIndexForAttributes:
1299 case TRANSACTION_getStreamVolumeIndex:
1300 case TRANSACTION_getVolumeIndexForAttributes:
1301 case TRANSACTION_getMinVolumeIndexForAttributes:
1302 case TRANSACTION_getMaxVolumeIndexForAttributes:
1303 case TRANSACTION_isStreamActive:
1304 case TRANSACTION_isStreamActiveRemotely:
1305 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001306 case TRANSACTION_registerPolicyMixes:
1307 case TRANSACTION_setMasterMono:
1308 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001309 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001310 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001311 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001312 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001313 case TRANSACTION_setA11yServicesUids:
1314 case TRANSACTION_setUidDeviceAffinities:
1315 case TRANSACTION_removeUidDeviceAffinities:
1316 case TRANSACTION_setUserIdDeviceAffinities:
1317 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001318 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001319 case TRANSACTION_listAudioVolumeGroups:
1320 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1321 case TRANSACTION_acquireSoundTriggerSession:
1322 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001323 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001324 case TRANSACTION_setRttEnabled:
1325 case TRANSACTION_isCallScreenModeSupported:
1326 case TRANSACTION_setDevicesRoleForStrategy:
1327 case TRANSACTION_setSupportedSystemUsages:
1328 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001329 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001330 case TRANSACTION_getDevicesForRoleAndStrategy:
1331 case TRANSACTION_getDevicesForAttributes:
1332 case TRANSACTION_setAllowedCapturePolicy:
1333 case TRANSACTION_onNewAudioModulesAvailable:
1334 case TRANSACTION_setCurrentImeUid:
1335 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1336 case TRANSACTION_setDevicesRoleForCapturePreset:
1337 case TRANSACTION_addDevicesRoleForCapturePreset:
1338 case TRANSACTION_removeDevicesRoleForCapturePreset:
1339 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001340 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001341 case TRANSACTION_getSpatializer:
1342 case TRANSACTION_setPreferredMixerAttributes:
1343 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001344 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1345 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1346 __func__, code, IPCThreadState::self()->getCallingPid(),
1347 IPCThreadState::self()->getCallingUid());
1348 return INVALID_OPERATION;
1349 }
1350 } break;
1351 default:
1352 break;
1353 }
1354
Andy Hungc747c532022-03-07 21:41:14 -08001355 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1356 mediautils::TimeCheck check(
1357 std::string("IAudioPolicyService::").append(methodName),
1358 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1359 if (timeout) {
1360 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1361 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1362 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1363 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1364 .record();
1365 } else {
1366 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1367 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001368 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1369 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1370 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001371
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001372 switch (code) {
1373 case SHELL_COMMAND_TRANSACTION: {
1374 int in = data.readFileDescriptor();
1375 int out = data.readFileDescriptor();
1376 int err = data.readFileDescriptor();
1377 int argc = data.readInt32();
1378 Vector<String16> args;
1379 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1380 args.add(data.readString16());
1381 }
1382 sp<IBinder> unusedCallback;
1383 sp<IResultReceiver> resultReceiver;
1384 status_t status;
1385 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1386 return status;
1387 }
1388 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1389 return status;
1390 }
1391 status = shellCommand(in, out, err, args);
1392 if (resultReceiver != nullptr) {
1393 resultReceiver->send(status);
1394 }
1395 return NO_ERROR;
1396 }
1397 }
1398
Mathias Agopian65ab4712010-07-14 17:59:35 -07001399 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1400}
1401
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001402// ------------------- Shell command implementation -------------------
1403
1404// NOTE: This is a remote API - make sure all args are validated
1405status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1406 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1407 return PERMISSION_DENIED;
1408 }
1409 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1410 return BAD_VALUE;
1411 }
jovanakbe066e12019-09-02 11:54:39 -07001412 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001413 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001414 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001415 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001416 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001417 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001418 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1419 purgePermissionCache();
1420 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001421 } else if (args.size() == 1 && args[0] == String16("help")) {
1422 printHelp(out);
1423 return NO_ERROR;
1424 }
1425 printHelp(err);
1426 return BAD_VALUE;
1427}
1428
jovanakbe066e12019-09-02 11:54:39 -07001429static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1430 if (userId < 0) {
1431 ALOGE("Invalid user: %d", userId);
1432 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001433 return BAD_VALUE;
1434 }
jovanakbe066e12019-09-02 11:54:39 -07001435
1436 PermissionController pc;
1437 uid = pc.getPackageUid(packageName, 0);
1438 if (uid <= 0) {
1439 ALOGE("Unknown package: '%s'", String8(packageName).string());
1440 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1441 return BAD_VALUE;
1442 }
1443
1444 uid = multiuser_get_uid(userId, uid);
1445 return NO_ERROR;
1446}
1447
1448status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1449 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1450 if (!(args.size() == 3 || args.size() == 5)) {
1451 printHelp(err);
1452 return BAD_VALUE;
1453 }
1454
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001455 bool active = false;
1456 if (args[2] == String16("active")) {
1457 active = true;
1458 } else if ((args[2] != String16("idle"))) {
1459 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1460 return BAD_VALUE;
1461 }
jovanakbe066e12019-09-02 11:54:39 -07001462
1463 int userId = 0;
1464 if (args.size() >= 5 && args[3] == String16("--user")) {
1465 userId = atoi(String8(args[4]));
1466 }
1467
1468 uid_t uid;
1469 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1470 return BAD_VALUE;
1471 }
1472
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001473 sp<UidPolicy> uidPolicy;
1474 {
1475 Mutex::Autolock _l(mLock);
1476 uidPolicy = mUidPolicy;
1477 }
1478 if (uidPolicy) {
1479 uidPolicy->addOverrideUid(uid, active);
1480 return NO_ERROR;
1481 }
1482 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001483}
1484
1485status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001486 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1487 if (!(args.size() == 2 || args.size() == 4)) {
1488 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001489 return BAD_VALUE;
1490 }
jovanakbe066e12019-09-02 11:54:39 -07001491
1492 int userId = 0;
1493 if (args.size() >= 4 && args[2] == String16("--user")) {
1494 userId = atoi(String8(args[3]));
1495 }
1496
1497 uid_t uid;
1498 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1499 return BAD_VALUE;
1500 }
1501
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001502 sp<UidPolicy> uidPolicy;
1503 {
1504 Mutex::Autolock _l(mLock);
1505 uidPolicy = mUidPolicy;
1506 }
1507 if (uidPolicy) {
1508 uidPolicy->removeOverrideUid(uid);
1509 return NO_ERROR;
1510 }
1511 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001512}
1513
1514status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001515 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1516 if (!(args.size() == 2 || args.size() == 4)) {
1517 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001518 return BAD_VALUE;
1519 }
jovanakbe066e12019-09-02 11:54:39 -07001520
1521 int userId = 0;
1522 if (args.size() >= 4 && args[2] == String16("--user")) {
1523 userId = atoi(String8(args[3]));
1524 }
1525
1526 uid_t uid;
1527 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1528 return BAD_VALUE;
1529 }
1530
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001531 sp<UidPolicy> uidPolicy;
1532 {
1533 Mutex::Autolock _l(mLock);
1534 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001535 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001536 if (uidPolicy) {
1537 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1538 }
1539 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001540}
1541
1542status_t AudioPolicyService::printHelp(int out) {
1543 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001544 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1545 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1546 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001547 " help print this message\n");
1548}
1549
Eric Laurent0d13fea2022-11-04 17:12:08 +01001550status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1551 const audio_config_base_t& config,
1552 const audio_output_flags_t flags) {
1553 return mUsecaseValidator->registerStream(output, config, flags);
1554}
1555
1556status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1557 return mUsecaseValidator->unregisterStream(output);
1558}
1559
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001560// ----------- AudioPolicyService::UidPolicy implementation ----------
1561
1562void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001563 status_t res = mAm.linkToDeath(this);
1564 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001565 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001566 | ActivityManager::UID_OBSERVER_ACTIVE
1567 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001568 ActivityManager::PROCESS_STATE_UNKNOWN,
1569 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001570 if (!res) {
1571 Mutex::Autolock _l(mLock);
1572 mObserverRegistered = true;
1573 } else {
1574 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001575
Steven Moreland2f348142019-07-02 15:59:07 -07001576 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001577 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001578}
1579
1580void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001581 mAm.unlinkToDeath(this);
1582 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001583 Mutex::Autolock _l(mLock);
1584 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001585}
1586
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001587void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1588 Mutex::Autolock _l(mLock);
1589 mCachedUids.clear();
1590 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001591}
1592
Eric Laurente8c8b432018-10-17 10:08:02 -07001593void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001594 bool needToReregister = false;
1595 {
1596 Mutex::Autolock _l(mLock);
1597 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001598 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001599 if (needToReregister) {
1600 // Looks like ActivityManager has died previously, attempt to re-register.
1601 registerSelf();
1602 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001603}
1604
1605bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1606 if (isServiceUid(uid)) return true;
1607 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001608 {
1609 Mutex::Autolock _l(mLock);
1610 auto overrideIter = mOverrideUids.find(uid);
1611 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001612 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001613 }
1614 // In an absense of the ActivityManager, assume everything to be active.
1615 if (!mObserverRegistered) return true;
1616 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001617 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001618 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001619 }
1620 }
1621 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001622 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001623 {
1624 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001625 mCachedUids.insert(std::pair<uid_t,
1626 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1627 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001628 }
1629 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001630}
1631
Eric Laurente8c8b432018-10-17 10:08:02 -07001632int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1633 if (isServiceUid(uid)) {
1634 return ActivityManager::PROCESS_STATE_TOP;
1635 }
1636 checkRegistered();
1637 {
1638 Mutex::Autolock _l(mLock);
1639 auto overrideIter = mOverrideUids.find(uid);
1640 if (overrideIter != mOverrideUids.end()) {
1641 if (overrideIter->second.first) {
1642 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1643 return overrideIter->second.second;
1644 } else {
1645 auto cacheIter = mCachedUids.find(uid);
1646 if (cacheIter != mCachedUids.end()) {
1647 return cacheIter->second.second;
1648 }
1649 }
1650 }
1651 return ActivityManager::PROCESS_STATE_UNKNOWN;
1652 }
1653 // In an absense of the ActivityManager, assume everything to be active.
1654 if (!mObserverRegistered) {
1655 return ActivityManager::PROCESS_STATE_TOP;
1656 }
1657 auto cacheIter = mCachedUids.find(uid);
1658 if (cacheIter != mCachedUids.end()) {
1659 if (cacheIter->second.first) {
1660 return cacheIter->second.second;
1661 } else {
1662 return ActivityManager::PROCESS_STATE_UNKNOWN;
1663 }
1664 }
1665 }
1666 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001667 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001668 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1669 if (active) {
1670 state = am.getUidProcessState(uid, String16("audioserver"));
1671 }
1672 {
1673 Mutex::Autolock _l(mLock);
1674 mCachedUids.insert(std::pair<uid_t,
1675 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1676 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001677
Eric Laurente8c8b432018-10-17 10:08:02 -07001678 return state;
1679}
1680
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001681void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001682 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001683}
1684
1685void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001686 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001687}
1688
1689void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001690 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001691}
1692
Eric Laurente8c8b432018-10-17 10:08:02 -07001693void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1694 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001695 int64_t procStateSeq __unused,
1696 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001697 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1698 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001699 }
1700}
1701
Austin Borgerdddb7552023-03-30 17:53:01 -07001702void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001703}
1704
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001705void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001706 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1707}
1708
1709void AudioPolicyService::UidPolicy::notifyService() {
1710 sp<AudioPolicyService> service = mService.promote();
1711 if (service != nullptr) {
1712 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001713 }
1714}
1715
Eric Laurente8c8b432018-10-17 10:08:02 -07001716void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1717 std::pair<bool, int>> *uids,
1718 uid_t uid,
1719 bool active,
1720 int state,
1721 bool insert) {
1722 if (isServiceUid(uid)) {
1723 return;
1724 }
1725 bool wasActive = isUidActive(uid);
1726 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001727 {
1728 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001729 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001730 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001731 if (wasActive != isUidActive(uid) || state != previousState) {
1732 notifyService();
1733 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001734}
1735
Eric Laurente8c8b432018-10-17 10:08:02 -07001736void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1737 std::pair<bool, int>> *uids,
1738 uid_t uid,
1739 bool active,
1740 int state,
1741 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001742 auto it = uids->find(uid);
1743 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001744 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001745 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1746 it->second.first = active;
1747 }
1748 if (it->second.first) {
1749 it->second.second = state;
1750 } else {
1751 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1752 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001753 } else {
1754 uids->erase(it);
1755 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001756 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1757 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1758 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001759 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001760}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001761
Eric Laurent4eb58f12018-12-07 16:41:02 -08001762bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001763 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001764 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001765 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001766 continue;
1767 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001768 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1769 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001770 return true;
1771 }
1772 }
1773 return false;
1774}
1775
Eric Laurentb78763e2018-10-17 10:08:02 -07001776bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1777{
1778 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1779 return it != mA11yUids.end();
1780}
1781
Oscar Azucena829d90d2022-01-28 17:17:56 -08001782void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1783 mAssistantUids.clear();
1784 mAssistantUids = uids;
1785}
1786
1787bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1788{
1789 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1790 return it != mAssistantUids.end();
1791}
1792
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001793void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1794 mActiveAssistantUids = activeUids;
1795}
1796
1797bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1798{
1799 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1800 mActiveAssistantUids.end(), uid);
1801 return it != mActiveAssistantUids.end();
1802}
1803
Oscar Azucena829d90d2022-01-28 17:17:56 -08001804void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1805 const size_t SIZE = 256;
1806 char buffer[SIZE];
1807 String8 result;
1808 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1809 snprintf(buffer, SIZE, "\t%s: \n", title);
1810 result.append(buffer);
1811 int counter = 0;
1812 if (uids.empty()) {
1813 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1814 result.append(buffer);
1815 return;
1816 }
1817 for (const auto &uid : uids) {
1818 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1819 result.append(buffer);
1820 }
1821 };
1822
1823 snprintf(buffer, SIZE, "UID Policy:\n");
1824 result.append(buffer);
1825 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1826 result.append(buffer);
1827
1828 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001829 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001830
1831 appendUidsToResult("Accessibility UIDs", mA11yUids);
1832
1833 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1834 result.append(buffer);
1835
1836 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1837 result.append(buffer);
1838
1839 write(fd, result.string(), result.size());
1840}
1841
Michael Groovercfd28302018-12-11 19:16:46 -08001842// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1843void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1844 SensorPrivacyManager spm;
1845 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1846 spm.addSensorPrivacyListener(this);
1847}
1848
1849void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1850 SensorPrivacyManager spm;
1851 spm.removeSensorPrivacyListener(this);
1852}
1853
1854bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1855 return mSensorPrivacyEnabled;
1856}
1857
Evan Seversond8dc6832022-01-27 10:47:03 -08001858binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1859 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001860 mSensorPrivacyEnabled = enabled;
1861 sp<AudioPolicyService> service = mService.promote();
1862 if (service != nullptr) {
1863 service->updateUidStates();
1864 }
1865 return binder::Status::ok();
1866}
1867
Mathias Agopian65ab4712010-07-14 17:59:35 -07001868// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1869
Eric Laurentbfb1b832013-01-07 09:53:42 -08001870AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1871 const wp<AudioPolicyService>& service)
1872 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001873{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001874}
1875
1876
1877AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1878{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001879 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001880 release_wake_lock(mName.string());
1881 }
1882 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001883}
1884
1885void AudioPolicyService::AudioCommandThread::onFirstRef()
1886{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001887 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001888}
1889
1890bool AudioPolicyService::AudioCommandThread::threadLoop()
1891{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001892 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001893
1894 mLock.lock();
1895 while (!exitPending())
1896 {
Eric Laurent59a89232014-06-08 14:14:17 -07001897 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001898 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001899 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001900 nsecs_t curTime = systemTime();
1901 // commands are sorted by increasing time stamp: execute them from index 0 and up
1902 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001903 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001904 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001905 if (mAudioCommands.isEmpty()) {
1906 ++numTimesBecameEmpty;
1907 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001908 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001909
1910 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001911 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001912 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001913 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001914 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001915 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001916 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1917 data->mVolume,
1918 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001919 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001920 }break;
1921 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001922 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001923 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
1924 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001925 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001926 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07001927 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001928 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001929 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001930 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001931 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001932 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07001933 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001934 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07001935 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001936 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001937 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001938 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001939 ALOGV("AudioCommandThread() processing stop output portId %d",
1940 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001941 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001942 if (svc == 0) {
1943 break;
1944 }
1945 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001946 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001947 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001948 }break;
1949 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001950 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001951 ALOGV("AudioCommandThread() processing release output portId %d",
1952 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001953 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001954 if (svc == 0) {
1955 break;
1956 }
1957 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001958 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08001959 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001960 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001961 case CREATE_AUDIO_PATCH: {
1962 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1963 ALOGV("AudioCommandThread() processing create audio patch");
1964 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1965 if (af == 0) {
1966 command->mStatus = PERMISSION_DENIED;
1967 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07001968 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001969 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07001970 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001971 }
1972 } break;
1973 case RELEASE_AUDIO_PATCH: {
1974 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1975 ALOGV("AudioCommandThread() processing release audio patch");
1976 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1977 if (af == 0) {
1978 command->mStatus = PERMISSION_DENIED;
1979 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07001980 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001981 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07001982 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001983 }
1984 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001985 case UPDATE_AUDIOPORT_LIST: {
1986 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001987 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001988 if (svc == 0) {
1989 break;
1990 }
1991 mLock.unlock();
1992 svc->doOnAudioPortListUpdate();
1993 mLock.lock();
1994 }break;
1995 case UPDATE_AUDIOPATCH_LIST: {
1996 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07001997 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001998 if (svc == 0) {
1999 break;
2000 }
2001 mLock.unlock();
2002 svc->doOnAudioPatchListUpdate();
2003 mLock.lock();
2004 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002005 case CHANGED_AUDIOVOLUMEGROUP: {
2006 AudioVolumeGroupData *data =
2007 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2008 ALOGV("AudioCommandThread() processing update audio volume group");
2009 svc = mService.promote();
2010 if (svc == 0) {
2011 break;
2012 }
2013 mLock.unlock();
2014 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2015 mLock.lock();
2016 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002017 case SET_AUDIOPORT_CONFIG: {
2018 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2019 ALOGV("AudioCommandThread() processing set port config");
2020 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2021 if (af == 0) {
2022 command->mStatus = PERMISSION_DENIED;
2023 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002024 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002025 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002026 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002027 }
2028 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002029 case DYN_POLICY_MIX_STATE_UPDATE: {
2030 DynPolicyMixStateUpdateData *data =
2031 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002032 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2033 data->mRegId.string(), data->mState);
2034 svc = mService.promote();
2035 if (svc == 0) {
2036 break;
2037 }
2038 mLock.unlock();
2039 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2040 mLock.lock();
2041 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002042 case RECORDING_CONFIGURATION_UPDATE: {
2043 RecordingConfigurationUpdateData *data =
2044 (RecordingConfigurationUpdateData *)command->mParam.get();
2045 ALOGV("AudioCommandThread() processing recording configuration update");
2046 svc = mService.promote();
2047 if (svc == 0) {
2048 break;
2049 }
2050 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002051 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002052 &data->mClientConfig, data->mClientEffects,
2053 &data->mDeviceConfig, data->mEffects,
2054 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002055 mLock.lock();
2056 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002057 case SET_EFFECT_SUSPENDED: {
2058 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2059 ALOGV("AudioCommandThread() processing set effect suspended");
2060 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2061 if (af != 0) {
2062 mLock.unlock();
2063 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2064 mLock.lock();
2065 }
2066 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002067 case AUDIO_MODULES_UPDATE: {
2068 ALOGV("AudioCommandThread() processing audio modules update");
2069 svc = mService.promote();
2070 if (svc == 0) {
2071 break;
2072 }
2073 mLock.unlock();
2074 svc->doOnNewAudioModulesAvailable();
2075 mLock.lock();
2076 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002077 case ROUTING_UPDATED: {
2078 ALOGV("AudioCommandThread() processing routing update");
2079 svc = mService.promote();
2080 if (svc == 0) {
2081 break;
2082 }
2083 mLock.unlock();
2084 svc->doOnRoutingUpdated();
2085 mLock.lock();
2086 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002087
Eric Laurented726cc2021-07-01 14:26:41 +02002088 case UPDATE_UID_STATES: {
2089 ALOGV("AudioCommandThread() processing updateUID states");
2090 svc = mService.promote();
2091 if (svc == 0) {
2092 break;
2093 }
2094 mLock.unlock();
2095 svc->updateUidStates();
2096 mLock.lock();
2097 } break;
2098
Eric Laurent15903592022-02-24 20:44:36 +01002099 case CHECK_SPATIALIZER_OUTPUT: {
2100 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002101 svc = mService.promote();
2102 if (svc == 0) {
2103 break;
2104 }
2105 mLock.unlock();
2106 svc->doOnCheckSpatializer();
2107 mLock.lock();
2108 } break;
2109
Eric Laurent15903592022-02-24 20:44:36 +01002110 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2111 ALOGV("AudioCommandThread() processing update spatializer tracks");
2112 svc = mService.promote();
2113 if (svc == 0) {
2114 break;
2115 }
2116 mLock.unlock();
2117 svc->doOnUpdateActiveSpatializerTracks();
2118 mLock.lock();
2119 } break;
2120
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002121 case VOL_RANGE_INIT_REQUEST: {
2122 ALOGV("AudioCommandThread() processing volume range init request");
2123 svc = mService.promote();
2124 if (svc == 0) {
2125 break;
2126 }
2127 mLock.unlock();
2128 svc->doOnVolumeRangeInitRequest();
2129 mLock.lock();
2130 } break;
2131
Mathias Agopian65ab4712010-07-14 17:59:35 -07002132 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002133 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002134 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002135 {
2136 Mutex::Autolock _l(command->mLock);
2137 if (command->mWaitStatus) {
2138 command->mWaitStatus = false;
2139 command->mCond.signal();
2140 }
2141 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002142 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002143 // release mLock before releasing strong reference on the service as
2144 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2145 // acquires mLock.
2146 mLock.unlock();
2147 svc.clear();
2148 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002149 } else {
2150 waitTime = mAudioCommands[0]->mTime - curTime;
2151 break;
2152 }
2153 }
Zach Janga754b4f2015-10-27 01:29:34 +00002154
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002155 // release delayed commands wake lock as many times as we made the queue is
2156 // empty during popping.
2157 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002158 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002159 }
2160
2161 // At this stage we have either an empty command queue or the first command in the queue
2162 // has a finite delay. So unless we are exiting it is safe to wait.
2163 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002164 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002165 if (waitTime == -1) {
2166 mWaitWorkCV.wait(mLock);
2167 } else {
2168 mWaitWorkCV.waitRelative(mLock, waitTime);
2169 }
Eric Laurent59a89232014-06-08 14:14:17 -07002170 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002171 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002172 // release delayed commands wake lock before quitting
2173 if (!mAudioCommands.isEmpty()) {
2174 release_wake_lock(mName.string());
2175 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002176 mLock.unlock();
2177 return false;
2178}
2179
2180status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2181{
2182 const size_t SIZE = 256;
2183 char buffer[SIZE];
2184 String8 result;
2185
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002186 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002187 if (!locked) {
2188 String8 result2(kCmdDeadlockedString);
2189 write(fd, result2.string(), result2.size());
2190 }
2191
2192 snprintf(buffer, SIZE, "- Commands:\n");
2193 result = String8(buffer);
2194 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002195 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002196 mAudioCommands[i]->dump(buffer, SIZE);
2197 result.append(buffer);
2198 }
2199 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002200 if (mLastCommand != 0) {
2201 mLastCommand->dump(buffer, SIZE);
2202 result.append(buffer);
2203 } else {
2204 result.append(" none\n");
2205 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002206
2207 write(fd, result.string(), result.size());
2208
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002209 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002210
2211 return NO_ERROR;
2212}
2213
Glenn Kastenfff6d712012-01-12 16:38:12 -08002214status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002215 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002216 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002217 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002218{
Eric Laurent0ede8922014-05-09 18:04:42 -07002219 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002220 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002221 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002222 data->mStream = stream;
2223 data->mVolume = volume;
2224 data->mIO = output;
2225 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002226 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002227 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002228 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002229 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002230}
2231
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002232status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002233 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002234 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002235{
Eric Laurent0ede8922014-05-09 18:04:42 -07002236 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002237 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002238 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002239 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002240 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002241 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002242 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002243 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002244 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002245 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002246}
2247
2248status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2249{
Eric Laurent0ede8922014-05-09 18:04:42 -07002250 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002251 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002252 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002253 data->mVolume = volume;
2254 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002255 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002256 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002257 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002258}
2259
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002260void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2261 audio_session_t sessionId,
2262 bool suspended)
2263{
2264 sp<AudioCommand> command = new AudioCommand();
2265 command->mCommand = SET_EFFECT_SUSPENDED;
2266 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2267 data->mEffectId = effectId;
2268 data->mSessionId = sessionId;
2269 data->mSuspended = suspended;
2270 command->mParam = data;
2271 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2272 effectId, sessionId, suspended);
2273 sendCommand(command);
2274}
2275
2276
Eric Laurentd7fe0862018-07-14 16:48:01 -07002277void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002278{
Eric Laurent0ede8922014-05-09 18:04:42 -07002279 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002280 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002281 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002282 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002283 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002284 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002285 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002286}
2287
Eric Laurentd7fe0862018-07-14 16:48:01 -07002288void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002289{
Eric Laurent0ede8922014-05-09 18:04:42 -07002290 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002291 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002292 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002293 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002294 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002295 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002296 sendCommand(command);
2297}
2298
Eric Laurent951f4552014-05-20 10:48:17 -07002299status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2300 const struct audio_patch *patch,
2301 audio_patch_handle_t *handle,
2302 int delayMs)
2303{
2304 status_t status = NO_ERROR;
2305
2306 sp<AudioCommand> command = new AudioCommand();
2307 command->mCommand = CREATE_AUDIO_PATCH;
2308 CreateAudioPatchData *data = new CreateAudioPatchData();
2309 data->mPatch = *patch;
2310 data->mHandle = *handle;
2311 command->mParam = data;
2312 command->mWaitStatus = true;
2313 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2314 status = sendCommand(command, delayMs);
2315 if (status == NO_ERROR) {
2316 *handle = data->mHandle;
2317 }
2318 return status;
2319}
2320
2321status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2322 int delayMs)
2323{
2324 sp<AudioCommand> command = new AudioCommand();
2325 command->mCommand = RELEASE_AUDIO_PATCH;
2326 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2327 data->mHandle = handle;
2328 command->mParam = data;
2329 command->mWaitStatus = true;
2330 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2331 return sendCommand(command, delayMs);
2332}
2333
Eric Laurentb52c1522014-05-20 11:27:36 -07002334void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2335{
2336 sp<AudioCommand> command = new AudioCommand();
2337 command->mCommand = UPDATE_AUDIOPORT_LIST;
2338 ALOGV("AudioCommandThread() adding update audio port list");
2339 sendCommand(command);
2340}
2341
Eric Laurented726cc2021-07-01 14:26:41 +02002342void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2343{
2344 sp<AudioCommand> command = new AudioCommand();
2345 command->mCommand = UPDATE_UID_STATES;
2346 ALOGV("AudioCommandThread() adding update UID states");
2347 sendCommand(command);
2348}
2349
Eric Laurentb52c1522014-05-20 11:27:36 -07002350void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2351{
2352 sp<AudioCommand>command = new AudioCommand();
2353 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2354 ALOGV("AudioCommandThread() adding update audio patch list");
2355 sendCommand(command);
2356}
2357
François Gaffiecfe17322018-11-07 13:41:29 +01002358void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2359 int flags)
2360{
2361 sp<AudioCommand>command = new AudioCommand();
2362 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2363 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2364 data->mGroup = group;
2365 data->mFlags = flags;
2366 command->mParam = data;
2367 ALOGV("AudioCommandThread() adding audio volume group changed");
2368 sendCommand(command);
2369}
2370
Eric Laurente1715a42014-05-20 11:30:42 -07002371status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2372 const struct audio_port_config *config, int delayMs)
2373{
2374 sp<AudioCommand> command = new AudioCommand();
2375 command->mCommand = SET_AUDIOPORT_CONFIG;
2376 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2377 data->mConfig = *config;
2378 command->mParam = data;
2379 command->mWaitStatus = true;
2380 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2381 return sendCommand(command, delayMs);
2382}
2383
Jean-Michel Trivide801052015-04-14 19:10:14 -07002384void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002385 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002386{
2387 sp<AudioCommand> command = new AudioCommand();
2388 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2389 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2390 data->mRegId = regId;
2391 data->mState = state;
2392 command->mParam = data;
2393 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2394 regId.string(), state);
2395 sendCommand(command);
2396}
2397
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002398void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002399 int event,
2400 const record_client_info_t *clientInfo,
2401 const audio_config_base_t *clientConfig,
2402 std::vector<effect_descriptor_t> clientEffects,
2403 const audio_config_base_t *deviceConfig,
2404 std::vector<effect_descriptor_t> effects,
2405 audio_patch_handle_t patchHandle,
2406 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002407{
2408 sp<AudioCommand>command = new AudioCommand();
2409 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2410 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2411 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002412 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002413 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002414 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002415 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002416 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002417 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002418 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002419 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002420 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2421 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002422 sendCommand(command);
2423}
2424
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002425void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2426{
2427 sp<AudioCommand> command = new AudioCommand();
2428 command->mCommand = AUDIO_MODULES_UPDATE;
2429 sendCommand(command);
2430}
2431
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002432void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2433{
2434 sp<AudioCommand>command = new AudioCommand();
2435 command->mCommand = ROUTING_UPDATED;
2436 ALOGV("AudioCommandThread() adding routing update");
2437 sendCommand(command);
2438}
2439
Eric Laurent81dd0f52021-07-05 11:54:40 +02002440void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2441{
2442 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002443 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002444 ALOGV("AudioCommandThread() adding check spatializer");
2445 sendCommand(command);
2446}
2447
Eric Laurent15903592022-02-24 20:44:36 +01002448void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2449{
2450 sp<AudioCommand>command = new AudioCommand();
2451 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2452 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2453 sendCommand(command);
2454}
2455
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002456void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2457{
2458 sp<AudioCommand>command = new AudioCommand();
2459 command->mCommand = VOL_RANGE_INIT_REQUEST;
2460 ALOGV("AudioCommandThread() adding volume range init request");
2461 sendCommand(command);
2462}
2463
Eric Laurent0ede8922014-05-09 18:04:42 -07002464status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2465{
2466 {
2467 Mutex::Autolock _l(mLock);
2468 insertCommand_l(command, delayMs);
2469 mWaitWorkCV.signal();
2470 }
2471 Mutex::Autolock _l(command->mLock);
2472 while (command->mWaitStatus) {
2473 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2474 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2475 command->mStatus = TIMED_OUT;
2476 command->mWaitStatus = false;
2477 }
2478 }
2479 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002480}
2481
Mathias Agopian65ab4712010-07-14 17:59:35 -07002482// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002483void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002484{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002485 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002486 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002487 command->mTime = systemTime() + milliseconds(delayMs);
2488
2489 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002490 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002491 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2492 }
2493
2494 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002495 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002496 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002497 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2498 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002499
2500 // create audio patch or release audio patch commands are equivalent
2501 // with regard to filtering
2502 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2503 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2504 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2505 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2506 continue;
2507 }
2508 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002509
2510 switch (command->mCommand) {
2511 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002512 ParametersData *data = (ParametersData *)command->mParam.get();
2513 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002514 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002515 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002516 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002517 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2518 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2519 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002520 String8 key;
2521 String8 value;
2522 param.getAt(j, key, value);
2523 for (size_t k = 0; k < param2.size(); k++) {
2524 String8 key2;
2525 String8 value2;
2526 param2.getAt(k, key2, value2);
2527 if (key2 == key) {
2528 param2.remove(key2);
2529 ALOGV("Filtering out parameter %s", key2.string());
2530 break;
2531 }
2532 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002533 }
2534 // if all keys have been filtered out, remove the command.
2535 // otherwise, update the key value pairs
2536 if (param2.size() == 0) {
2537 removedCommands.add(command2);
2538 } else {
2539 data2->mKeyValuePairs = param2.toString();
2540 }
Eric Laurent21e54562013-09-23 12:08:05 -07002541 command->mTime = command2->mTime;
2542 // force delayMs to non 0 so that code below does not request to wait for
2543 // command status as the command is now delayed
2544 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002545 } break;
2546
2547 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002548 VolumeData *data = (VolumeData *)command->mParam.get();
2549 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002550 if (data->mIO != data2->mIO) break;
2551 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002552 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002553 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002554 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002555 command->mTime = command2->mTime;
2556 // force delayMs to non 0 so that code below does not request to wait for
2557 // command status as the command is now delayed
2558 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002559 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002560
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002561 case SET_VOICE_VOLUME: {
2562 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2563 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2564 ALOGV("Filtering out voice volume command value %f replaced by %f",
2565 data2->mVolume, data->mVolume);
2566 removedCommands.add(command2);
2567 command->mTime = command2->mTime;
2568 // force delayMs to non 0 so that code below does not request to wait for
2569 // command status as the command is now delayed
2570 delayMs = 1;
2571 } break;
2572
Eric Laurente45b48a2014-09-04 16:40:57 -07002573 case CREATE_AUDIO_PATCH:
2574 case RELEASE_AUDIO_PATCH: {
2575 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002576 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002577 if (command->mCommand == CREATE_AUDIO_PATCH) {
2578 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002579 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002580 } else {
2581 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002582 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002583 }
2584 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002585 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002586 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2587 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002588 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002589 } else {
2590 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002591 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002592 }
2593 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002594 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2595 same output. */
2596 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2597 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2598 bool isOutputDiff = false;
2599 if (patch.num_sources == patch2.num_sources) {
2600 for (unsigned count = 0; count < patch.num_sources; count++) {
2601 if (patch.sources[count].id != patch2.sources[count].id) {
2602 isOutputDiff = true;
2603 break;
2604 }
2605 }
2606 if (isOutputDiff)
2607 break;
2608 }
2609 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002610 ALOGV("Filtering out %s audio patch command for handle %d",
2611 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2612 removedCommands.add(command2);
2613 command->mTime = command2->mTime;
2614 // force delayMs to non 0 so that code below does not request to wait for
2615 // command status as the command is now delayed
2616 delayMs = 1;
2617 } break;
2618
Jean-Michel Trivide801052015-04-14 19:10:14 -07002619 case DYN_POLICY_MIX_STATE_UPDATE: {
2620
2621 } break;
2622
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002623 case RECORDING_CONFIGURATION_UPDATE: {
2624
2625 } break;
2626
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002627 case ROUTING_UPDATED: {
2628
2629 } break;
2630
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002631 case VOL_RANGE_INIT_REQUEST: {
2632 // command may come from different requests, do not filter
2633 } break;
2634
Mathias Agopian65ab4712010-07-14 17:59:35 -07002635 default:
2636 break;
2637 }
2638 }
2639
2640 // remove filtered commands
2641 for (size_t j = 0; j < removedCommands.size(); j++) {
2642 // removed commands always have time stamps greater than current command
2643 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002644 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002645 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002646 mAudioCommands.removeAt(k);
2647 break;
2648 }
2649 }
2650 }
2651 removedCommands.clear();
2652
Eric Laurentaa79bef2015-01-15 14:33:51 -08002653 // Disable wait for status if delay is not 0.
2654 // Except for create audio patch command because the returned patch handle
2655 // is needed by audio policy manager
2656 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002657 command->mWaitStatus = false;
2658 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002659
Mathias Agopian65ab4712010-07-14 17:59:35 -07002660 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002661 ALOGV("inserting command: %d at index %zd, num commands %zu",
2662 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002663 mAudioCommands.insertAt(command, i + 1);
2664}
2665
2666void AudioPolicyService::AudioCommandThread::exit()
2667{
Steve Block3856b092011-10-20 11:56:00 +01002668 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002669 {
2670 AutoMutex _l(mLock);
2671 requestExit();
2672 mWaitWorkCV.signal();
2673 }
Zach Janga754b4f2015-10-27 01:29:34 +00002674 // Note that we can call it from the thread loop if all other references have been released
2675 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002676 requestExitAndWait();
2677}
2678
2679void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2680{
2681 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2682 mCommand,
2683 (int)ns2s(mTime),
2684 (int)ns2ms(mTime)%1000,
2685 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002686 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002687}
2688
Dima Zavinfce7a472011-04-19 22:30:36 -07002689/******* helpers for the service_ops callbacks defined below *********/
2690void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2691 const char *keyValuePairs,
2692 int delayMs)
2693{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002694 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002695 delayMs);
2696}
2697
2698int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2699 float volume,
2700 audio_io_handle_t output,
2701 int delayMs)
2702{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002703 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002704 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002705}
2706
Dima Zavinfce7a472011-04-19 22:30:36 -07002707int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2708{
2709 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2710}
2711
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002712void AudioPolicyService::setEffectSuspended(int effectId,
2713 audio_session_t sessionId,
2714 bool suspended)
2715{
2716 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2717}
2718
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002719Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002720{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002721 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002722 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002723}
2724
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002725
Dima Zavinfce7a472011-04-19 22:30:36 -07002726extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002727audio_module_handle_t aps_load_hw_module(void *service __unused,
2728 const char *name);
2729audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002730 audio_devices_t *pDevices,
2731 uint32_t *pSamplingRate,
2732 audio_format_t *pFormat,
2733 audio_channel_mask_t *pChannelMask,
2734 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002735 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002736
Eric Laurent2d388ec2014-03-07 13:25:54 -08002737audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002738 audio_module_handle_t module,
2739 audio_devices_t *pDevices,
2740 uint32_t *pSamplingRate,
2741 audio_format_t *pFormat,
2742 audio_channel_mask_t *pChannelMask,
2743 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002744 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002745 const audio_offload_info_t *offloadInfo);
2746audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002747 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002748 audio_io_handle_t output2);
2749int aps_close_output(void *service __unused, audio_io_handle_t output);
2750int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2751int aps_restore_output(void *service __unused, audio_io_handle_t output);
2752audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002753 audio_devices_t *pDevices,
2754 uint32_t *pSamplingRate,
2755 audio_format_t *pFormat,
2756 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002757 audio_in_acoustics_t acoustics __unused);
2758audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002759 audio_module_handle_t module,
2760 audio_devices_t *pDevices,
2761 uint32_t *pSamplingRate,
2762 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002763 audio_channel_mask_t *pChannelMask);
2764int aps_close_input(void *service __unused, audio_io_handle_t input);
2765int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002766int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002767 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002768 audio_io_handle_t dst_output);
2769char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2770 const char *keys);
2771void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2772 const char *kv_pairs, int delay_ms);
2773int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002774 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002775 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002776int aps_set_voice_volume(void *service, float volume, int delay_ms);
2777};
Dima Zavinfce7a472011-04-19 22:30:36 -07002778
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002779} // namespace android