blob: 5d22ed4ce1ce1a71378b9498af7fcc975e97ef1f [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>
37#include "AudioPolicyService.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070038#include <hardware_legacy/power.h>
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -080039#include <media/AidlConversion.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070040#include <media/AudioEffect.h>
Chih-Hung Hsiehc84d9d22014-11-14 13:33:34 -080041#include <media/AudioParameter.h>
Andy Hungc747c532022-03-07 21:41:14 -080042#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070043#include <mediautils/ServiceUtilities.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080044#include <mediautils/TimeCheck.h>
Michael Groovercfd28302018-12-11 19:16:46 -080045#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070046
Dima Zavin64760242011-05-11 14:15:23 -070047#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070048#include <system/audio_policy.h>
Mikhail Naganov68e3f642023-04-28 13:06:32 -070049#include <AudioPolicyConfig.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053050#include <AudioPolicyManager.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070051
Mathias Agopian65ab4712010-07-14 17:59:35 -070052namespace android {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080053using binder::Status;
Mathias Agopian65ab4712010-07-14 17:59:35 -070054
Glenn Kasten8dad0e32012-01-09 08:41:22 -080055static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
56static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053057static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
Mathias Agopian65ab4712010-07-14 17:59:35 -070058
Mikhail Naganov959e2d02019-03-28 11:08:19 -070059static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Mathias Agopian65ab4712010-07-14 17:59:35 -070060
Eric Laurent0ede8922014-05-09 18:04:42 -070061static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010062
Svet Ganovf4ddfef2018-01-16 07:37:58 -080063static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070064
Andy Hungc747c532022-03-07 21:41:14 -080065// Creates an association between Binder code to name for IAudioPolicyService.
66#define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
67BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
68BINDER_METHOD_ENTRY(setDeviceConnectionState) \
69BINDER_METHOD_ENTRY(getDeviceConnectionState) \
70BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
71BINDER_METHOD_ENTRY(setPhoneState) \
72BINDER_METHOD_ENTRY(setForceUse) \
73BINDER_METHOD_ENTRY(getForceUse) \
74BINDER_METHOD_ENTRY(getOutput) \
75BINDER_METHOD_ENTRY(getOutputForAttr) \
76BINDER_METHOD_ENTRY(startOutput) \
77BINDER_METHOD_ENTRY(stopOutput) \
78BINDER_METHOD_ENTRY(releaseOutput) \
79BINDER_METHOD_ENTRY(getInputForAttr) \
80BINDER_METHOD_ENTRY(startInput) \
81BINDER_METHOD_ENTRY(stopInput) \
82BINDER_METHOD_ENTRY(releaseInput) \
83BINDER_METHOD_ENTRY(initStreamVolume) \
84BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
85BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
86BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
87BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
88BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
90BINDER_METHOD_ENTRY(getStrategyForStream) \
91BINDER_METHOD_ENTRY(getDevicesForAttributes) \
92BINDER_METHOD_ENTRY(getOutputForEffect) \
93BINDER_METHOD_ENTRY(registerEffect) \
94BINDER_METHOD_ENTRY(unregisterEffect) \
95BINDER_METHOD_ENTRY(setEffectEnabled) \
96BINDER_METHOD_ENTRY(moveEffectsToIo) \
97BINDER_METHOD_ENTRY(isStreamActive) \
98BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
99BINDER_METHOD_ENTRY(isSourceActive) \
100BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
101BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
102BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
103BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
104BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
105BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
106BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
107BINDER_METHOD_ENTRY(getOffloadSupport) \
108BINDER_METHOD_ENTRY(isDirectOutputSupported) \
109BINDER_METHOD_ENTRY(listAudioPorts) \
110BINDER_METHOD_ENTRY(getAudioPort) \
111BINDER_METHOD_ENTRY(createAudioPatch) \
112BINDER_METHOD_ENTRY(releaseAudioPatch) \
113BINDER_METHOD_ENTRY(listAudioPatches) \
114BINDER_METHOD_ENTRY(setAudioPortConfig) \
115BINDER_METHOD_ENTRY(registerClient) \
116BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
117BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
118BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
119BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
120BINDER_METHOD_ENTRY(getPhoneState) \
121BINDER_METHOD_ENTRY(registerPolicyMixes) \
122BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
123BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
124BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
125BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
126BINDER_METHOD_ENTRY(startAudioSource) \
127BINDER_METHOD_ENTRY(stopAudioSource) \
128BINDER_METHOD_ENTRY(setMasterMono) \
129BINDER_METHOD_ENTRY(getMasterMono) \
130BINDER_METHOD_ENTRY(getStreamVolumeDB) \
131BINDER_METHOD_ENTRY(getSurroundFormats) \
132BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
133BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
134BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
135BINDER_METHOD_ENTRY(setAssistantServicesUids) \
136BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
137BINDER_METHOD_ENTRY(setA11yServicesUids) \
138BINDER_METHOD_ENTRY(setCurrentImeUid) \
139BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
140BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800141BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800142BINDER_METHOD_ENTRY(listAudioProductStrategies) \
143BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
144BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
145BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
146BINDER_METHOD_ENTRY(setRttEnabled) \
147BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
148BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
149BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000150BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800151BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
152BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
157BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
158BINDER_METHOD_ENTRY(getSpatializer) \
159BINDER_METHOD_ENTRY(canBeSpatialized) \
160BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000161BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
162BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
163BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
164BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
165BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800166
167// singleton for Binder Method Statistics for IAudioPolicyService
168static auto& getIAudioPolicyServiceStatistics() {
169 using Code = int;
170
171#pragma push_macro("BINDER_METHOD_ENTRY")
172#undef BINDER_METHOD_ENTRY
173#define BINDER_METHOD_ENTRY(ENTRY) \
174 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
175
176 static mediautils::MethodStatistics<Code> methodStatistics{
177 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
178 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
179 };
180#pragma pop_macro("BINDER_METHOD_ENTRY")
181
182 return methodStatistics;
183}
184
Mathias Agopian65ab4712010-07-14 17:59:35 -0700185// ----------------------------------------------------------------------------
186
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530187static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
188{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700189 AudioPolicyManager *apm = nullptr;
190 media::AudioPolicyConfig apmConfig;
191 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
192 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
193 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
194 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
195 "Only default engine is currently supported with the AIDL HAL");
196 apm = new AudioPolicyManager(config,
197 loadApmEngineLibraryAndCreateEngine(
198 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
199 clientInterface);
200 } else {
201 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
202 apm = new AudioPolicyManager(config,
203 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
204 clientInterface);
205 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530206 status_t status = apm->initialize();
207 if (status != NO_ERROR) {
208 delete apm;
209 apm = nullptr;
210 }
211 return apm;
212}
213
214static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
215{
216 delete interface;
217}
218// ----------------------------------------------------------------------------
219
Mathias Agopian65ab4712010-07-14 17:59:35 -0700220AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700221 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700222 mAudioPolicyManager(NULL),
223 mAudioPolicyClient(NULL),
224 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530225 mCaptureStateNotifier(false),
226 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100227 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
228 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800229 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530230}
231
232void AudioPolicyService::loadAudioPolicyManager()
233{
234 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
235 if (mLibraryHandle != nullptr) {
236 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
237 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
238 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
239 const char *lastError = dlerror();
240 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
241 __func__, lastError != nullptr ? lastError : "no error");
242
243 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
244 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
245 lastError = dlerror();
246 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
247 __func__, lastError != nullptr ? lastError : "no error");
248 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
249 unloadAudioPolicyManager();
250 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
251 }
252 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700253}
254
255void AudioPolicyService::onFirstRef()
256{
Andy Hungd47aca22022-03-15 11:50:51 -0700257 // Log an AudioPolicy "constructor" mediametrics event on first ref.
258 // This records the time it takes to load the audio modules and devices.
259 mediametrics::Defer defer([beginNs = systemTime()] {
260 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
261 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
262 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
263 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700264 {
265 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800266
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700267 // start audio commands thread
268 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
269 // start output activity command thread
270 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700271
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700272 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530273
274 loadAudioPolicyManager();
275 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700276 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200277
bryant_liuba2b4392014-06-11 16:49:30 +0800278 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000279 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
280 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects(effectsFactoryHal);
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000281 sp<UidPolicy> uidPolicy = new UidPolicy(this);
282 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700283 {
284 Mutex::Autolock _l(mLock);
285 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000286 mUidPolicy = uidPolicy;
287 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700288 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000289 uidPolicy->registerSelf();
290 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200291
Eric Laurent81dd0f52021-07-05 11:54:40 +0200292 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200293 if (mAudioPolicyManager != nullptr) {
294 Mutex::Autolock _l(mLock);
295 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
296 AudioDeviceTypeAddrVector devices;
297 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
298 if (hasSpatializer) {
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000299 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200300 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700301 if (mSpatializer == nullptr) {
302 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
303 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
304 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
305 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200306 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200307 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700308}
309
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530310void AudioPolicyService::unloadAudioPolicyManager()
311{
312 ALOGV("%s ", __func__);
313 if (mLibraryHandle != nullptr) {
314 dlclose(mLibraryHandle);
315 }
316 mLibraryHandle = nullptr;
317 mCreateAudioPolicyManager = nullptr;
318 mDestroyAudioPolicyManager = nullptr;
319}
320
Mathias Agopian65ab4712010-07-14 17:59:35 -0700321AudioPolicyService::~AudioPolicyService()
322{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700323 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700324 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700325
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530326 mDestroyAudioPolicyManager(mAudioPolicyManager);
327 unloadAudioPolicyManager();
328
Eric Laurentdce54a12014-03-10 12:19:46 -0700329 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700330
331 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800332 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800333
334 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800335 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000336
337 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800338 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700339}
340
341// A notification client is always registered by AudioSystem when the client process
342// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800343Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700344{
Eric Laurent12590252015-08-21 18:40:20 -0700345 if (client == 0) {
346 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800347 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700348 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800349 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700350
351 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800352 pid_t pid = IPCThreadState::self()->getCallingPid();
353 int64_t token = ((int64_t)uid<<32) | pid;
354
355 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700356 sp<NotificationClient> notificationClient = new NotificationClient(this,
357 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800358 uid,
359 pid);
360 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700361
luochaojiang908c7d72018-06-21 14:58:04 +0800362 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700363
Marco Nelissenf8880202014-11-14 07:58:25 -0800364 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700365 binder->linkToDeath(notificationClient);
366 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800367 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700368}
369
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800370Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700371{
372 Mutex::Autolock _l(mNotificationClientsLock);
373
374 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800375 pid_t pid = IPCThreadState::self()->getCallingPid();
376 int64_t token = ((int64_t)uid<<32) | pid;
377
378 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800379 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700380 }
luochaojiang908c7d72018-06-21 14:58:04 +0800381 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800382 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700383}
384
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800385Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100386{
387 Mutex::Autolock _l(mNotificationClientsLock);
388
389 uid_t uid = IPCThreadState::self()->getCallingUid();
390 pid_t pid = IPCThreadState::self()->getCallingPid();
391 int64_t token = ((int64_t)uid<<32) | pid;
392
393 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800394 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100395 }
396 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800397 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100398}
399
Eric Laurentb52c1522014-05-20 11:27:36 -0700400// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800401void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700402{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000403 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800404 {
405 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800406 int64_t token = ((int64_t)uid<<32) | pid;
407 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800408 for (size_t i = 0; i < mNotificationClients.size(); i++) {
409 if (mNotificationClients.valueAt(i)->uid() == uid) {
410 hasSameUid = true;
411 break;
412 }
413 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000414 }
415 {
416 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800417 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700418 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700419 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700420 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800421 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700422}
423
424void AudioPolicyService::onAudioPortListUpdate()
425{
426 mOutputCommandThread->updateAudioPortListCommand();
427}
428
429void AudioPolicyService::doOnAudioPortListUpdate()
430{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800431 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700432 for (size_t i = 0; i < mNotificationClients.size(); i++) {
433 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
434 }
435}
436
437void AudioPolicyService::onAudioPatchListUpdate()
438{
439 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700440}
441
Eric Laurentb52c1522014-05-20 11:27:36 -0700442void AudioPolicyService::doOnAudioPatchListUpdate()
443{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800444 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700445 for (size_t i = 0; i < mNotificationClients.size(); i++) {
446 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
447 }
448}
449
François Gaffiecfe17322018-11-07 13:41:29 +0100450void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
451{
452 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
453}
454
455void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
456{
457 Mutex::Autolock _l(mNotificationClientsLock);
458 for (size_t i = 0; i < mNotificationClients.size(); i++) {
459 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
460 }
461}
462
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700463void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700464{
465 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
466 regId.string(), state);
467 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
468}
469
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700470void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700471{
472 Mutex::Autolock _l(mNotificationClientsLock);
473 for (size_t i = 0; i < mNotificationClients.size(); i++) {
474 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
475 }
476}
477
Eric Laurenta9f86652018-11-28 17:23:11 -0800478void AudioPolicyService::onRecordingConfigurationUpdate(
479 int event,
480 const record_client_info_t *clientInfo,
481 const audio_config_base_t *clientConfig,
482 std::vector<effect_descriptor_t> clientEffects,
483 const audio_config_base_t *deviceConfig,
484 std::vector<effect_descriptor_t> effects,
485 audio_patch_handle_t patchHandle,
486 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800487{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800488 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800489 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800490}
491
Eric Laurenta9f86652018-11-28 17:23:11 -0800492void AudioPolicyService::doOnRecordingConfigurationUpdate(
493 int event,
494 const record_client_info_t *clientInfo,
495 const audio_config_base_t *clientConfig,
496 std::vector<effect_descriptor_t> clientEffects,
497 const audio_config_base_t *deviceConfig,
498 std::vector<effect_descriptor_t> effects,
499 audio_patch_handle_t patchHandle,
500 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800501{
502 Mutex::Autolock _l(mNotificationClientsLock);
503 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800504 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800505 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800506 }
507}
508
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700509void AudioPolicyService::onRoutingUpdated()
510{
511 mOutputCommandThread->routingChangedCommand();
512}
513
514void AudioPolicyService::doOnRoutingUpdated()
515{
516 Mutex::Autolock _l(mNotificationClientsLock);
517 for (size_t i = 0; i < mNotificationClients.size(); i++) {
518 mNotificationClients.valueAt(i)->onRoutingUpdated();
519 }
520}
521
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000522void AudioPolicyService::onVolumeRangeInitRequest()
523{
524 mOutputCommandThread->volRangeInitReqCommand();
525}
526
527void AudioPolicyService::doOnVolumeRangeInitRequest()
528{
529 Mutex::Autolock _l(mNotificationClientsLock);
530 for (size_t i = 0; i < mNotificationClients.size(); i++) {
531 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
532 }
533}
534
Eric Laurent81dd0f52021-07-05 11:54:40 +0200535void AudioPolicyService::onCheckSpatializer()
536{
537 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200538 onCheckSpatializer_l();
539}
540
541void AudioPolicyService::onCheckSpatializer_l()
542{
543 if (mSpatializer != nullptr) {
544 mOutputCommandThread->checkSpatializerCommand();
545 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200546}
547
548void AudioPolicyService::doOnCheckSpatializer()
549{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200550 ALOGV("%s mSpatializer %p level %d",
551 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200552
Eric Laurent39095982021-08-24 18:29:27 +0200553 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200554 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200555 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
556 audio_io_handle_t currentOutput = mSpatializer->getOutput();
557 audio_io_handle_t newOutput;
558 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
559 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200560
561 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200562 status_t status =
563 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100564 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
565 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200566 if (status == NO_ERROR && currentOutput == newOutput) {
567 return;
568 }
Eric Laurent15903592022-02-24 20:44:36 +0100569 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200570 mLock.unlock();
571 // It is OK to call detachOutput() is none is already attached.
572 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200573 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
574 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200575 }
Eric Laurent39095982021-08-24 18:29:27 +0200576 mLock.lock();
577 if (status != NO_ERROR) {
578 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
579 }
580 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
581 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200582 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200583
Eric Laurent39095982021-08-24 18:29:27 +0200584 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200585 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200586 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200587 }
588 }
589 }
590}
591
Eric Laurent11094172022-04-05 18:27:42 +0200592size_t AudioPolicyService::countActiveClientsOnOutput_l(
593 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100594 size_t count = 0;
595 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
596 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200597 if (client->io == output && client->active
598 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100599 count++;
600 }
601 }
602 return count;
603}
604
605void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
606 if (mSpatializer == nullptr) {
607 return;
608 }
609 mOutputCommandThread->updateActiveSpatializerTracksCommand();
610}
611
612void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
613{
Eric Laurent21270b62022-07-04 15:11:29 +0200614 if (mSpatializer == nullptr) {
615 return;
616 }
617 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200618 size_t activeClients;
619 {
620 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200621 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100622 }
Eric Laurent21270b62022-07-04 15:11:29 +0200623 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100624}
625
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800626status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
627 audio_patch_handle_t *handle,
628 int delayMs)
629{
630 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
631}
632
633status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
634 int delayMs)
635{
636 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
637}
638
Eric Laurente1715a42014-05-20 11:30:42 -0700639status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
640 int delayMs)
641{
642 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
643}
644
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800645AudioPolicyService::NotificationClient::NotificationClient(
646 const sp<AudioPolicyService>& service,
647 const sp<media::IAudioPolicyServiceClient>& client,
648 uid_t uid,
649 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800650 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100651 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700652{
653}
654
655AudioPolicyService::NotificationClient::~NotificationClient()
656{
657}
658
659void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
660{
661 sp<NotificationClient> keep(this);
662 sp<AudioPolicyService> service = mService.promote();
663 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800664 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700665 }
666}
667
668void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
669{
Eric Laurente8726fe2015-06-26 09:39:24 -0700670 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700671 mAudioPolicyServiceClient->onAudioPortListUpdate();
672 }
673}
674
675void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
676{
Eric Laurente8726fe2015-06-26 09:39:24 -0700677 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700678 mAudioPolicyServiceClient->onAudioPatchListUpdate();
679 }
680}
Eric Laurent57dae992011-07-24 13:36:09 -0700681
Pattydd807582021-11-04 21:01:03 +0800682void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100683 int flags)
684{
685 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
686 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
687 }
688}
689
690
Jean-Michel Trivide801052015-04-14 19:10:14 -0700691void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700692 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700693{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700694 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800695 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
696 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800697 }
698}
699
700void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800701 int event,
702 const record_client_info_t *clientInfo,
703 const audio_config_base_t *clientConfig,
704 std::vector<effect_descriptor_t> clientEffects,
705 const audio_config_base_t *deviceConfig,
706 std::vector<effect_descriptor_t> effects,
707 audio_patch_handle_t patchHandle,
708 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800709{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700710 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800711 status_t status = [&]() -> status_t {
712 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
713 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
714 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700715 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700716 legacy2aidl_audio_config_base_t_AudioConfigBase(
717 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800718 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
719 convertContainer<std::vector<media::EffectDescriptor>>(
720 clientEffects,
721 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700722 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700723 legacy2aidl_audio_config_base_t_AudioConfigBase(
724 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800725 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
726 convertContainer<std::vector<media::EffectDescriptor>>(
727 effects,
728 legacy2aidl_effect_descriptor_t_EffectDescriptor));
729 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
730 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700731 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
732 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800733 return aidl_utils::statusTFromBinderStatus(
734 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
735 clientInfoAidl,
736 clientConfigAidl,
737 clientEffectsAidl,
738 deviceConfigAidl,
739 effectsAidl,
740 patchHandleAidl,
741 sourceAidl));
742 }();
743 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700744 }
745}
746
Eric Laurente8726fe2015-06-26 09:39:24 -0700747void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
748{
749 mAudioPortCallbacksEnabled = enabled;
750}
751
François Gaffiecfe17322018-11-07 13:41:29 +0100752void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
753{
754 mAudioVolumeGroupCallbacksEnabled = enabled;
755}
Eric Laurente8726fe2015-06-26 09:39:24 -0700756
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700757void AudioPolicyService::NotificationClient::onRoutingUpdated()
758{
759 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
760 mAudioPolicyServiceClient->onRoutingUpdated();
761 }
762}
763
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000764void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
765{
766 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
767 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
768 }
769}
770
Mathias Agopian65ab4712010-07-14 17:59:35 -0700771void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700772 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700773 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700774}
775
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000776static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700777{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000778 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
779}
780
781static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
782{
783 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700784}
785
786status_t AudioPolicyService::dumpInternals(int fd)
787{
788 const size_t SIZE = 256;
789 char buffer[SIZE];
790 String8 result;
791
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000792 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800793 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000794 std::stringstream msg;
795 size_t i = 0;
796 for (auto usage : mSupportedSystemUsages) {
797 if (i++ != 0) msg << ", ";
798 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
799 msg << strUsage;
800 } else {
801 msg << usage << " (unknown)";
802 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800803 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000804 if (i == 0) {
805 msg << "None";
806 }
807 msg << std::endl;
808 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800809
Mathias Agopian65ab4712010-07-14 17:59:35 -0700810 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800811
812 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700813 return NO_ERROR;
814}
815
Eric Laurente8c8b432018-10-17 10:08:02 -0700816void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800817{
Eric Laurente8c8b432018-10-17 10:08:02 -0700818 Mutex::Autolock _l(mLock);
819 updateUidStates_l();
820}
821
822void AudioPolicyService::updateUidStates_l()
823{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800824// Go over all active clients and allow capture (does not force silence) in the
825// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800826// The client is in the active assistant list
827// AND is TOP
828// AND an accessibility service is TOP
829// AND source is either VOICE_RECOGNITION OR HOTWORD
830// OR there is no active privacy sensitive capture or call
831// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
832// AND source is VOICE_RECOGNITION OR HOTWORD
833// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800834// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700835// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800836// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800837// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800838// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
839// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800840// OR The client is an accessibility service
841// AND Is on TOP
842// AND the source is VOICE_RECOGNITION or HOTWORD
843// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700844// AND there is no active privacy sensitive capture or call
845// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800846// AND is on TOP
847// AND the source is VOICE_RECOGNITION or HOTWORD
848// OR the client source is virtual (remote submix, call audio TX or RX...)
849// OR the client source is HOTWORD
850// AND is on TOP
851// OR all active clients are using HOTWORD source
852// AND no call is active
853// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
854// OR the client is the current InputMethodService
855// AND a RTT call is active AND the source is VOICE_RECOGNITION
856// OR Any client
857// AND The assistant is not on TOP
858// AND is on TOP or latest started
859// AND there is no active privacy sensitive capture or call
860// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800861
Eric Laurent4e947da2019-10-17 15:24:06 -0700862
Eric Laurent4eb58f12018-12-07 16:41:02 -0800863 sp<AudioRecordClient> topActive;
864 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800865 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700866 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800867 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700868
Eric Laurenta46bedb2018-12-07 18:01:26 -0800869 nsecs_t topStartNs = 0;
870 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800871 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800872 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800873 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800874 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
875 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800876 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800877 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700878 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800879 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
880 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700881 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700882 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700883 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800884
Michael Groovercfd28302018-12-11 19:16:46 -0800885 // if Sensor Privacy is enabled then all recordings should be silenced.
886 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
887 silenceAllRecordings_l();
888 return;
889 }
890
Eric Laurente8c8b432018-10-17 10:08:02 -0700891 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
892 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000893 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
894 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800895 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700896 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800897 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700898
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700899 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700900 // clients which app is in IDLE state are not eligible for top active or
901 // latest active
902 if (appState == APP_STATE_IDLE) {
903 continue;
904 }
905
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700906 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700907 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800908 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700909 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700910 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800911 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800912 bool isPrivacySensitive =
913 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700914
Eric Laurentc21d5692020-02-25 10:24:36 -0800915 if (appState == APP_STATE_TOP) {
916 if (isPrivacySensitive) {
917 if (current->startTimeNs > topSensitiveStartNs) {
918 topSensitiveActive = current;
919 topSensitiveStartNs = current->startTimeNs;
920 }
921 } else {
922 if (current->startTimeNs > topStartNs) {
923 topActive = current;
924 topStartNs = current->startTimeNs;
925 }
926 }
927 if (isAssistant) {
928 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800929 if (isActiveAssistant) {
930 useActiveAssistantList = true;
931 } else if (!useActiveAssistantList) {
932 if (current->startTimeNs > latestAssistantStartNs) {
933 latestActiveAssistant = current;
934 latestAssistantStartNs = current->startTimeNs;
935 }
936 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800937 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800938 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800939 // Clients capturing for HOTWORD are not considered
940 // for latest active to avoid masking regular clients started before
941 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
942 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
943 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700944 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
945 // is marked latest sensitive active even if another app qualifies.
946 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700947 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700948 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700949 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000950 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700951 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700952 latestSensitiveActiveOrComm = current;
953 latestSensitiveStartNs = current->startTimeNs;
954 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800955 }
956 isSensitiveActive = true;
957 } else {
958 if (current->startTimeNs > latestStartNs) {
959 latestActive = current;
960 latestStartNs = current->startTimeNs;
961 }
962 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800963 }
964 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700965 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
966 onlyHotwordActive = false;
967 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100968 if (currentUid == mPhoneStateOwnerUid &&
969 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700970 isPhoneStateOwnerActive = true;
971 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800972 }
973
Eric Laurent1ff16a72019-03-14 18:35:04 -0700974 // if no active client with UI on Top, consider latest active as top
975 if (topActive == nullptr) {
976 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800977 topStartNs = latestStartNs;
978 }
979 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700980 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800981 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700982 } else if (latestSensitiveActiveOrComm != nullptr) {
983 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
984 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700985 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000986 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700987 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700988 topSensitiveActive = latestSensitiveActiveOrComm;
989 topSensitiveStartNs = latestSensitiveStartNs;
990 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800991 }
992
993 // If both privacy sensitive and regular capture are active:
994 // if the regular capture is privileged
995 // allow concurrency
996 // else
997 // favor the privacy sensitive case
998 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700999 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001000 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001001 }
1002
1003 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1004 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001005 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001006 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001007 if (!current->active) {
1008 continue;
1009 }
1010
Eric Laurent4eb58f12018-12-07 16:41:02 -08001011 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001012 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001013 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001014 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001015 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001016 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1017 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001018
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001019 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001020 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001021 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001022 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001023 bool canCaptureCommunication = recordClient->canCaptureOutput
1024 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001025 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001026 return !(isInCall && !canCaptureCall)
1027 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001028 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001029
1030 // By default allow capture if:
1031 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001032 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001033 // AND there is no active privacy sensitive capture or call
1034 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001035 bool allowSensitiveCapture =
1036 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001037 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001038 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001039 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001040 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001041
Eric Laurented726cc2021-07-01 14:26:41 +02001042 if (!current->hasOp()) {
1043 // Never allow capture if app op is denied
1044 allowCapture = false;
1045 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001046 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1047 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001048 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001049 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001050 // Active assistant list is not being used
1051 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001052 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001053 // OR there is no active privacy sensitive capture or call
1054 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1055 // AND is latest TOP assistant AND
1056 // uses VOICE_RECOGNITION OR uses HOTWORD
1057 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001058 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001059 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001060 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001061 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001062 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001063 && canCaptureIfInCallOrCommunication(current)) {
1064 if (isTopOrLatestAssistant
1065 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1066 || source == AUDIO_SOURCE_HOTWORD)) {
1067 allowCapture = true;
1068 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1069 allowCapture = true;
1070 }
1071 }
1072 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1073 // For assistant on active list and on top allow capture if:
1074 // An accessibility service is on TOP
1075 // AND the source is VOICE_RECOGNITION or HOTWORD
1076 // OR there is no active privacy sensitive capture or call
1077 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1078 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1079 if (isA11yOnTop) {
1080 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1081 allowCapture = true;
1082 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001083 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001084 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001085 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1086 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001087 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001088 }
1089 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001090 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001091 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001092 // The assistant is not on TOP
1093 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001094 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001095 // OR
1096 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1097 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001098 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001099 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001100 allowCapture = true;
1101 }
Eric Laurent589171c2019-07-25 18:04:29 -07001102 if (isA11yOnTop) {
1103 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1104 allowCapture = true;
1105 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001106 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001107 } else if (source == AUDIO_SOURCE_HOTWORD) {
1108 // For HOTWORD source allow capture when not on TOP if:
1109 // All active clients are using HOTWORD source
1110 // AND no call is active
1111 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001112 if (onlyHotwordActive
1113 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001114 allowCapture = true;
1115 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001116 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001117 // For current InputMethodService allow capture if:
1118 // A RTT call is active AND the source is VOICE_RECOGNITION
1119 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1120 allowCapture = true;
1121 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001122 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001123 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001124 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001125 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001126 }
1127}
1128
Michael Groovercfd28302018-12-11 19:16:46 -08001129void AudioPolicyService::silenceAllRecordings_l() {
1130 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1131 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001132 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001133 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001134 }
Michael Groovercfd28302018-12-11 19:16:46 -08001135 }
1136}
1137
Eric Laurente8c8b432018-10-17 10:08:02 -07001138/* static */
1139app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001140
1141 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001142 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001143 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1144 // include persistent services
1145 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001146 }
1147 return APP_STATE_FOREGROUND;
1148}
1149
Eric Laurent4eb58f12018-12-07 16:41:02 -08001150/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001151bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001152{
1153 switch (source) {
1154 case AUDIO_SOURCE_VOICE_UPLINK:
1155 case AUDIO_SOURCE_VOICE_DOWNLINK:
1156 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001157 case AUDIO_SOURCE_REMOTE_SUBMIX:
1158 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001159 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001160 return true;
1161 default:
1162 break;
1163 }
1164 return false;
1165}
1166
Eric Laurented726cc2021-07-01 14:26:41 +02001167/* static */
1168bool AudioPolicyService::isAppOpSource(audio_source_t source)
1169{
1170 switch (source) {
1171 case AUDIO_SOURCE_FM_TUNER:
1172 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001173 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001174 return false;
1175 default:
1176 break;
1177 }
1178 return true;
1179}
1180
Eric Laurent8c7ef892021-06-10 13:32:16 +02001181void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001182{
1183 AutoCallerClear acc;
1184
1185 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001186 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001187 }
1188 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1189 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001190 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001191 if (client->silenced != silenced) {
1192 if (client->active) {
1193 if (silenced) {
1194 finishRecording(client->attributionSource, client->attributes.source);
1195 } else {
1196 std::stringstream msg;
1197 msg << "Audio recording un-silenced on session " << client->session;
1198 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1199 client->attributes.source)) {
1200 silenced = true;
1201 }
1202 }
1203 }
1204 af->setRecordSilenced(client->portId, silenced);
1205 client->silenced = silenced;
1206 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001207 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001208}
1209
Glenn Kasten0f11b512014-01-31 16:18:54 -08001210status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001211{
Glenn Kasten44deb052012-02-05 18:09:08 -08001212 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001213 dumpPermissionDenial(fd);
1214 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001215 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001216 if (!locked) {
1217 String8 result(kDeadlockedString);
1218 write(fd, result.string(), result.size());
1219 }
1220
1221 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001222
1223 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1224 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001225 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001226 mAudioCommandThread->dump(fd);
1227 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001228
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001229 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1230 write(fd, octPtr.string(), octPtr.size());
1231 if (mOutputCommandThread != 0) {
1232 mOutputCommandThread->dump(fd);
1233 }
1234
Eric Laurentdce54a12014-03-10 12:19:46 -07001235 if (mAudioPolicyManager) {
1236 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001237 } else {
1238 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1239 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001240 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001241
Kevin Rocard8be94972019-02-22 13:26:25 -08001242 mPackageManager.dump(fd);
1243
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001244 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001245
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001246 if (mSpatializer != nullptr) {
1247 std::string dumpString = mSpatializer->toString(1 /* level */);
1248 write(fd, dumpString.c_str(), dumpString.size());
1249 } else {
1250 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1251 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1252 }
1253
Andy Hungc747c532022-03-07 21:41:14 -08001254 {
1255 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1256 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1257 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1258 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001259 }
1260 return NO_ERROR;
1261}
1262
1263status_t AudioPolicyService::dumpPermissionDenial(int fd)
1264{
1265 const size_t SIZE = 256;
1266 char buffer[SIZE];
1267 String8 result;
1268 snprintf(buffer, SIZE, "Permission Denial: "
1269 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1270 IPCThreadState::self()->getCallingPid(),
1271 IPCThreadState::self()->getCallingUid());
1272 result.append(buffer);
1273 write(fd, result.string(), result.size());
1274 return NO_ERROR;
1275}
1276
1277status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001278 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001279 // make sure transactions reserved to AudioFlinger do not come from other processes
1280 switch (code) {
1281 case TRANSACTION_startOutput:
1282 case TRANSACTION_stopOutput:
1283 case TRANSACTION_releaseOutput:
1284 case TRANSACTION_getInputForAttr:
1285 case TRANSACTION_startInput:
1286 case TRANSACTION_stopInput:
1287 case TRANSACTION_releaseInput:
1288 case TRANSACTION_getOutputForEffect:
1289 case TRANSACTION_registerEffect:
1290 case TRANSACTION_unregisterEffect:
1291 case TRANSACTION_setEffectEnabled:
1292 case TRANSACTION_getStrategyForStream:
1293 case TRANSACTION_getOutputForAttr:
1294 case TRANSACTION_moveEffectsToIo:
1295 ALOGW("%s: transaction %d received from PID %d",
1296 __func__, code, IPCThreadState::self()->getCallingPid());
1297 return INVALID_OPERATION;
1298 default:
1299 break;
1300 }
1301
1302 // make sure the following transactions come from system components
1303 switch (code) {
1304 case TRANSACTION_setDeviceConnectionState:
1305 case TRANSACTION_handleDeviceConfigChange:
1306 case TRANSACTION_setPhoneState:
1307//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1308// case TRANSACTION_setForceUse:
1309 case TRANSACTION_initStreamVolume:
1310 case TRANSACTION_setStreamVolumeIndex:
1311 case TRANSACTION_setVolumeIndexForAttributes:
1312 case TRANSACTION_getStreamVolumeIndex:
1313 case TRANSACTION_getVolumeIndexForAttributes:
1314 case TRANSACTION_getMinVolumeIndexForAttributes:
1315 case TRANSACTION_getMaxVolumeIndexForAttributes:
1316 case TRANSACTION_isStreamActive:
1317 case TRANSACTION_isStreamActiveRemotely:
1318 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001319 case TRANSACTION_registerPolicyMixes:
1320 case TRANSACTION_setMasterMono:
1321 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001322 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001323 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001324 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001325 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001326 case TRANSACTION_setA11yServicesUids:
1327 case TRANSACTION_setUidDeviceAffinities:
1328 case TRANSACTION_removeUidDeviceAffinities:
1329 case TRANSACTION_setUserIdDeviceAffinities:
1330 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001331 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001332 case TRANSACTION_listAudioVolumeGroups:
1333 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1334 case TRANSACTION_acquireSoundTriggerSession:
1335 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001336 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001337 case TRANSACTION_setRttEnabled:
1338 case TRANSACTION_isCallScreenModeSupported:
1339 case TRANSACTION_setDevicesRoleForStrategy:
1340 case TRANSACTION_setSupportedSystemUsages:
1341 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001342 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001343 case TRANSACTION_getDevicesForRoleAndStrategy:
1344 case TRANSACTION_getDevicesForAttributes:
1345 case TRANSACTION_setAllowedCapturePolicy:
1346 case TRANSACTION_onNewAudioModulesAvailable:
1347 case TRANSACTION_setCurrentImeUid:
1348 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1349 case TRANSACTION_setDevicesRoleForCapturePreset:
1350 case TRANSACTION_addDevicesRoleForCapturePreset:
1351 case TRANSACTION_removeDevicesRoleForCapturePreset:
1352 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001353 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001354 case TRANSACTION_getSpatializer:
1355 case TRANSACTION_setPreferredMixerAttributes:
1356 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001357 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1358 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1359 __func__, code, IPCThreadState::self()->getCallingPid(),
1360 IPCThreadState::self()->getCallingUid());
1361 return INVALID_OPERATION;
1362 }
1363 } break;
1364 default:
1365 break;
1366 }
1367
Andy Hungc747c532022-03-07 21:41:14 -08001368 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1369 mediautils::TimeCheck check(
1370 std::string("IAudioPolicyService::").append(methodName),
1371 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1372 if (timeout) {
1373 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1374 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1375 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1376 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1377 .record();
1378 } else {
1379 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1380 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001381 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1382 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1383 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001384
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001385 switch (code) {
1386 case SHELL_COMMAND_TRANSACTION: {
1387 int in = data.readFileDescriptor();
1388 int out = data.readFileDescriptor();
1389 int err = data.readFileDescriptor();
1390 int argc = data.readInt32();
1391 Vector<String16> args;
1392 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1393 args.add(data.readString16());
1394 }
1395 sp<IBinder> unusedCallback;
1396 sp<IResultReceiver> resultReceiver;
1397 status_t status;
1398 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1399 return status;
1400 }
1401 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1402 return status;
1403 }
1404 status = shellCommand(in, out, err, args);
1405 if (resultReceiver != nullptr) {
1406 resultReceiver->send(status);
1407 }
1408 return NO_ERROR;
1409 }
1410 }
1411
Mathias Agopian65ab4712010-07-14 17:59:35 -07001412 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1413}
1414
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001415// ------------------- Shell command implementation -------------------
1416
1417// NOTE: This is a remote API - make sure all args are validated
1418status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1419 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1420 return PERMISSION_DENIED;
1421 }
1422 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1423 return BAD_VALUE;
1424 }
jovanakbe066e12019-09-02 11:54:39 -07001425 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001426 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001427 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001428 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001429 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001430 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001431 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1432 purgePermissionCache();
1433 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001434 } else if (args.size() == 1 && args[0] == String16("help")) {
1435 printHelp(out);
1436 return NO_ERROR;
1437 }
1438 printHelp(err);
1439 return BAD_VALUE;
1440}
1441
jovanakbe066e12019-09-02 11:54:39 -07001442static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1443 if (userId < 0) {
1444 ALOGE("Invalid user: %d", userId);
1445 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001446 return BAD_VALUE;
1447 }
jovanakbe066e12019-09-02 11:54:39 -07001448
1449 PermissionController pc;
1450 uid = pc.getPackageUid(packageName, 0);
1451 if (uid <= 0) {
1452 ALOGE("Unknown package: '%s'", String8(packageName).string());
1453 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1454 return BAD_VALUE;
1455 }
1456
1457 uid = multiuser_get_uid(userId, uid);
1458 return NO_ERROR;
1459}
1460
1461status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1462 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1463 if (!(args.size() == 3 || args.size() == 5)) {
1464 printHelp(err);
1465 return BAD_VALUE;
1466 }
1467
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001468 bool active = false;
1469 if (args[2] == String16("active")) {
1470 active = true;
1471 } else if ((args[2] != String16("idle"))) {
1472 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1473 return BAD_VALUE;
1474 }
jovanakbe066e12019-09-02 11:54:39 -07001475
1476 int userId = 0;
1477 if (args.size() >= 5 && args[3] == String16("--user")) {
1478 userId = atoi(String8(args[4]));
1479 }
1480
1481 uid_t uid;
1482 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1483 return BAD_VALUE;
1484 }
1485
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001486 sp<UidPolicy> uidPolicy;
1487 {
1488 Mutex::Autolock _l(mLock);
1489 uidPolicy = mUidPolicy;
1490 }
1491 if (uidPolicy) {
1492 uidPolicy->addOverrideUid(uid, active);
1493 return NO_ERROR;
1494 }
1495 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001496}
1497
1498status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001499 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1500 if (!(args.size() == 2 || args.size() == 4)) {
1501 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001502 return BAD_VALUE;
1503 }
jovanakbe066e12019-09-02 11:54:39 -07001504
1505 int userId = 0;
1506 if (args.size() >= 4 && args[2] == String16("--user")) {
1507 userId = atoi(String8(args[3]));
1508 }
1509
1510 uid_t uid;
1511 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1512 return BAD_VALUE;
1513 }
1514
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001515 sp<UidPolicy> uidPolicy;
1516 {
1517 Mutex::Autolock _l(mLock);
1518 uidPolicy = mUidPolicy;
1519 }
1520 if (uidPolicy) {
1521 uidPolicy->removeOverrideUid(uid);
1522 return NO_ERROR;
1523 }
1524 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001525}
1526
1527status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001528 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1529 if (!(args.size() == 2 || args.size() == 4)) {
1530 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001531 return BAD_VALUE;
1532 }
jovanakbe066e12019-09-02 11:54:39 -07001533
1534 int userId = 0;
1535 if (args.size() >= 4 && args[2] == String16("--user")) {
1536 userId = atoi(String8(args[3]));
1537 }
1538
1539 uid_t uid;
1540 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1541 return BAD_VALUE;
1542 }
1543
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001544 sp<UidPolicy> uidPolicy;
1545 {
1546 Mutex::Autolock _l(mLock);
1547 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001548 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001549 if (uidPolicy) {
1550 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1551 }
1552 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001553}
1554
1555status_t AudioPolicyService::printHelp(int out) {
1556 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001557 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1558 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1559 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001560 " help print this message\n");
1561}
1562
Eric Laurent0d13fea2022-11-04 17:12:08 +01001563status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1564 const audio_config_base_t& config,
1565 const audio_output_flags_t flags) {
1566 return mUsecaseValidator->registerStream(output, config, flags);
1567}
1568
1569status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1570 return mUsecaseValidator->unregisterStream(output);
1571}
1572
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001573// ----------- AudioPolicyService::UidPolicy implementation ----------
1574
1575void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001576 status_t res = mAm.linkToDeath(this);
1577 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001578 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001579 | ActivityManager::UID_OBSERVER_ACTIVE
1580 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001581 ActivityManager::PROCESS_STATE_UNKNOWN,
1582 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001583 if (!res) {
1584 Mutex::Autolock _l(mLock);
1585 mObserverRegistered = true;
1586 } else {
1587 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001588
Steven Moreland2f348142019-07-02 15:59:07 -07001589 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001590 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001591}
1592
1593void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001594 mAm.unlinkToDeath(this);
1595 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001596 Mutex::Autolock _l(mLock);
1597 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001598}
1599
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001600void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1601 Mutex::Autolock _l(mLock);
1602 mCachedUids.clear();
1603 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001604}
1605
Eric Laurente8c8b432018-10-17 10:08:02 -07001606void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001607 bool needToReregister = false;
1608 {
1609 Mutex::Autolock _l(mLock);
1610 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001611 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001612 if (needToReregister) {
1613 // Looks like ActivityManager has died previously, attempt to re-register.
1614 registerSelf();
1615 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001616}
1617
1618bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1619 if (isServiceUid(uid)) return true;
1620 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001621 {
1622 Mutex::Autolock _l(mLock);
1623 auto overrideIter = mOverrideUids.find(uid);
1624 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001625 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001626 }
1627 // In an absense of the ActivityManager, assume everything to be active.
1628 if (!mObserverRegistered) return true;
1629 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001630 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001631 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001632 }
1633 }
1634 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001635 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001636 {
1637 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001638 mCachedUids.insert(std::pair<uid_t,
1639 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1640 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001641 }
1642 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001643}
1644
Eric Laurente8c8b432018-10-17 10:08:02 -07001645int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1646 if (isServiceUid(uid)) {
1647 return ActivityManager::PROCESS_STATE_TOP;
1648 }
1649 checkRegistered();
1650 {
1651 Mutex::Autolock _l(mLock);
1652 auto overrideIter = mOverrideUids.find(uid);
1653 if (overrideIter != mOverrideUids.end()) {
1654 if (overrideIter->second.first) {
1655 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1656 return overrideIter->second.second;
1657 } else {
1658 auto cacheIter = mCachedUids.find(uid);
1659 if (cacheIter != mCachedUids.end()) {
1660 return cacheIter->second.second;
1661 }
1662 }
1663 }
1664 return ActivityManager::PROCESS_STATE_UNKNOWN;
1665 }
1666 // In an absense of the ActivityManager, assume everything to be active.
1667 if (!mObserverRegistered) {
1668 return ActivityManager::PROCESS_STATE_TOP;
1669 }
1670 auto cacheIter = mCachedUids.find(uid);
1671 if (cacheIter != mCachedUids.end()) {
1672 if (cacheIter->second.first) {
1673 return cacheIter->second.second;
1674 } else {
1675 return ActivityManager::PROCESS_STATE_UNKNOWN;
1676 }
1677 }
1678 }
1679 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001680 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001681 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1682 if (active) {
1683 state = am.getUidProcessState(uid, String16("audioserver"));
1684 }
1685 {
1686 Mutex::Autolock _l(mLock);
1687 mCachedUids.insert(std::pair<uid_t,
1688 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1689 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001690
Eric Laurente8c8b432018-10-17 10:08:02 -07001691 return state;
1692}
1693
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001694void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001695 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001696}
1697
1698void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001699 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001700}
1701
1702void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001703 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001704}
1705
Eric Laurente8c8b432018-10-17 10:08:02 -07001706void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1707 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001708 int64_t procStateSeq __unused,
1709 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001710 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1711 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001712 }
1713}
1714
Austin Borgerdddb7552023-03-30 17:53:01 -07001715void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001716}
1717
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001718void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001719 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1720}
1721
1722void AudioPolicyService::UidPolicy::notifyService() {
1723 sp<AudioPolicyService> service = mService.promote();
1724 if (service != nullptr) {
1725 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001726 }
1727}
1728
Eric Laurente8c8b432018-10-17 10:08:02 -07001729void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1730 std::pair<bool, int>> *uids,
1731 uid_t uid,
1732 bool active,
1733 int state,
1734 bool insert) {
1735 if (isServiceUid(uid)) {
1736 return;
1737 }
1738 bool wasActive = isUidActive(uid);
1739 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001740 {
1741 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001742 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001743 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001744 if (wasActive != isUidActive(uid) || state != previousState) {
1745 notifyService();
1746 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001747}
1748
Eric Laurente8c8b432018-10-17 10:08:02 -07001749void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1750 std::pair<bool, int>> *uids,
1751 uid_t uid,
1752 bool active,
1753 int state,
1754 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001755 auto it = uids->find(uid);
1756 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001757 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001758 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1759 it->second.first = active;
1760 }
1761 if (it->second.first) {
1762 it->second.second = state;
1763 } else {
1764 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1765 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001766 } else {
1767 uids->erase(it);
1768 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001769 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1770 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1771 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001772 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001773}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001774
Eric Laurent4eb58f12018-12-07 16:41:02 -08001775bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001776 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001777 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001778 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001779 continue;
1780 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001781 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1782 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001783 return true;
1784 }
1785 }
1786 return false;
1787}
1788
Eric Laurentb78763e2018-10-17 10:08:02 -07001789bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1790{
1791 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1792 return it != mA11yUids.end();
1793}
1794
Oscar Azucena829d90d2022-01-28 17:17:56 -08001795void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1796 mAssistantUids.clear();
1797 mAssistantUids = uids;
1798}
1799
1800bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1801{
1802 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1803 return it != mAssistantUids.end();
1804}
1805
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001806void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1807 mActiveAssistantUids = activeUids;
1808}
1809
1810bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1811{
1812 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1813 mActiveAssistantUids.end(), uid);
1814 return it != mActiveAssistantUids.end();
1815}
1816
Oscar Azucena829d90d2022-01-28 17:17:56 -08001817void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1818 const size_t SIZE = 256;
1819 char buffer[SIZE];
1820 String8 result;
1821 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1822 snprintf(buffer, SIZE, "\t%s: \n", title);
1823 result.append(buffer);
1824 int counter = 0;
1825 if (uids.empty()) {
1826 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1827 result.append(buffer);
1828 return;
1829 }
1830 for (const auto &uid : uids) {
1831 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1832 result.append(buffer);
1833 }
1834 };
1835
1836 snprintf(buffer, SIZE, "UID Policy:\n");
1837 result.append(buffer);
1838 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1839 result.append(buffer);
1840
1841 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001842 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001843
1844 appendUidsToResult("Accessibility UIDs", mA11yUids);
1845
1846 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1847 result.append(buffer);
1848
1849 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1850 result.append(buffer);
1851
1852 write(fd, result.string(), result.size());
1853}
1854
Michael Groovercfd28302018-12-11 19:16:46 -08001855// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1856void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1857 SensorPrivacyManager spm;
1858 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1859 spm.addSensorPrivacyListener(this);
1860}
1861
1862void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1863 SensorPrivacyManager spm;
1864 spm.removeSensorPrivacyListener(this);
1865}
1866
1867bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1868 return mSensorPrivacyEnabled;
1869}
1870
Evan Seversond8dc6832022-01-27 10:47:03 -08001871binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1872 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001873 mSensorPrivacyEnabled = enabled;
1874 sp<AudioPolicyService> service = mService.promote();
1875 if (service != nullptr) {
1876 service->updateUidStates();
1877 }
1878 return binder::Status::ok();
1879}
1880
Eric Laurented726cc2021-07-01 14:26:41 +02001881// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1882
1883// static
1884sp<AudioPolicyService::OpRecordAudioMonitor>
1885AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1886 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1887 wp<AudioCommandThread> commandThread)
1888{
Eric Laurent987ce102021-07-05 12:11:51 +02001889 if (isAudioServerOrRootUid(attributionSource.uid)) {
1890 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001891 attributionSource.toString().c_str());
1892 return nullptr;
1893 }
1894
1895 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1896 ALOGD("not monitoring app op for uid %d and source %d",
1897 attributionSource.uid, attr.source);
1898 return nullptr;
1899 }
1900
1901 if (!attributionSource.packageName.has_value()
1902 || attributionSource.packageName.value().size() == 0) {
1903 return nullptr;
1904 }
1905 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1906}
1907
1908AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1909 const AttributionSourceState& attributionSource, int32_t appOp,
1910 wp<AudioCommandThread> commandThread) :
1911 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1912 mCommandThread(commandThread)
1913{
1914}
1915
1916AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1917{
1918 if (mOpCallback != 0) {
1919 mAppOpsManager.stopWatchingMode(mOpCallback);
1920 }
1921 mOpCallback.clear();
1922}
1923
1924void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1925{
1926 checkOp();
1927 mOpCallback = new RecordAudioOpCallback(this);
1928 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1929 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1930 // since it controls the mic permission for legacy apps.
1931 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1932 mAttributionSource.packageName.value_or(""))),
1933 mOpCallback);
1934}
1935
1936bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1937 return mHasOp.load();
1938}
1939
1940// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1941// is updated in AppOp callback and in onFirstRef()
1942// Note this method is never called (and never to be) for audio server / root track
1943// due to the UID in createIfNeeded(). As a result for those record track, it's:
1944// - not called from constructor,
1945// - not called from RecordAudioOpCallback because the callback is not installed in this case
1946void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1947{
1948 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1949 // since it controls the mic permission for legacy apps.
1950 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1951 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1952 mAttributionSource.packageName.value_or(""))));
1953 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1954 // verbose logging only log when appOp changed
1955 ALOGI_IF(hasIt != mHasOp.load(),
1956 "App op %d missing, %ssilencing record %s",
1957 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1958 mHasOp.store(hasIt);
1959
1960 if (updateUidStates) {
1961 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1962 if (commandThread != nullptr) {
1963 commandThread->updateUidStatesCommand();
1964 }
1965 }
1966}
1967
1968AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1969 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1970{ }
1971
1972void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1973 const String16& packageName __unused) {
1974 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1975 if (monitor != NULL) {
1976 if (op != monitor->getOp()) {
1977 return;
1978 }
1979 monitor->checkOp(true);
1980 }
1981}
1982
1983
Mathias Agopian65ab4712010-07-14 17:59:35 -07001984// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1985
Eric Laurentbfb1b832013-01-07 09:53:42 -08001986AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1987 const wp<AudioPolicyService>& service)
1988 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001989{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001990}
1991
1992
1993AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1994{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001995 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001996 release_wake_lock(mName.string());
1997 }
1998 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001999}
2000
2001void AudioPolicyService::AudioCommandThread::onFirstRef()
2002{
Eric Laurentbfb1b832013-01-07 09:53:42 -08002003 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002004}
2005
2006bool AudioPolicyService::AudioCommandThread::threadLoop()
2007{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002008 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002009
2010 mLock.lock();
2011 while (!exitPending())
2012 {
Eric Laurent59a89232014-06-08 14:14:17 -07002013 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002014 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07002015 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002016 nsecs_t curTime = systemTime();
2017 // commands are sorted by increasing time stamp: execute them from index 0 and up
2018 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002019 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002020 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002021 if (mAudioCommands.isEmpty()) {
2022 ++numTimesBecameEmpty;
2023 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002024 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002025
2026 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002027 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002028 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002029 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07002030 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002031 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07002032 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
2033 data->mVolume,
2034 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002035 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002036 }break;
2037 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002038 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002039 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2040 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002041 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002042 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002043 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002044 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002045 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002046 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002047 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002048 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002049 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002050 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002051 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002052 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002053 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002054 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002055 ALOGV("AudioCommandThread() processing stop output portId %d",
2056 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002057 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002058 if (svc == 0) {
2059 break;
2060 }
2061 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002062 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002063 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002064 }break;
2065 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002066 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002067 ALOGV("AudioCommandThread() processing release output portId %d",
2068 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002069 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002070 if (svc == 0) {
2071 break;
2072 }
2073 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002074 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002075 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002076 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002077 case CREATE_AUDIO_PATCH: {
2078 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2079 ALOGV("AudioCommandThread() processing create audio patch");
2080 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2081 if (af == 0) {
2082 command->mStatus = PERMISSION_DENIED;
2083 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002084 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002085 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002086 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002087 }
2088 } break;
2089 case RELEASE_AUDIO_PATCH: {
2090 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2091 ALOGV("AudioCommandThread() processing release audio patch");
2092 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2093 if (af == 0) {
2094 command->mStatus = PERMISSION_DENIED;
2095 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002096 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002097 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002098 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002099 }
2100 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002101 case UPDATE_AUDIOPORT_LIST: {
2102 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002103 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002104 if (svc == 0) {
2105 break;
2106 }
2107 mLock.unlock();
2108 svc->doOnAudioPortListUpdate();
2109 mLock.lock();
2110 }break;
2111 case UPDATE_AUDIOPATCH_LIST: {
2112 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002113 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002114 if (svc == 0) {
2115 break;
2116 }
2117 mLock.unlock();
2118 svc->doOnAudioPatchListUpdate();
2119 mLock.lock();
2120 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002121 case CHANGED_AUDIOVOLUMEGROUP: {
2122 AudioVolumeGroupData *data =
2123 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2124 ALOGV("AudioCommandThread() processing update audio volume group");
2125 svc = mService.promote();
2126 if (svc == 0) {
2127 break;
2128 }
2129 mLock.unlock();
2130 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2131 mLock.lock();
2132 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002133 case SET_AUDIOPORT_CONFIG: {
2134 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2135 ALOGV("AudioCommandThread() processing set port config");
2136 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2137 if (af == 0) {
2138 command->mStatus = PERMISSION_DENIED;
2139 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002140 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002141 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002142 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002143 }
2144 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002145 case DYN_POLICY_MIX_STATE_UPDATE: {
2146 DynPolicyMixStateUpdateData *data =
2147 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002148 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2149 data->mRegId.string(), data->mState);
2150 svc = mService.promote();
2151 if (svc == 0) {
2152 break;
2153 }
2154 mLock.unlock();
2155 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2156 mLock.lock();
2157 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002158 case RECORDING_CONFIGURATION_UPDATE: {
2159 RecordingConfigurationUpdateData *data =
2160 (RecordingConfigurationUpdateData *)command->mParam.get();
2161 ALOGV("AudioCommandThread() processing recording configuration update");
2162 svc = mService.promote();
2163 if (svc == 0) {
2164 break;
2165 }
2166 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002167 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002168 &data->mClientConfig, data->mClientEffects,
2169 &data->mDeviceConfig, data->mEffects,
2170 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002171 mLock.lock();
2172 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002173 case SET_EFFECT_SUSPENDED: {
2174 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2175 ALOGV("AudioCommandThread() processing set effect suspended");
2176 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2177 if (af != 0) {
2178 mLock.unlock();
2179 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2180 mLock.lock();
2181 }
2182 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002183 case AUDIO_MODULES_UPDATE: {
2184 ALOGV("AudioCommandThread() processing audio modules update");
2185 svc = mService.promote();
2186 if (svc == 0) {
2187 break;
2188 }
2189 mLock.unlock();
2190 svc->doOnNewAudioModulesAvailable();
2191 mLock.lock();
2192 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002193 case ROUTING_UPDATED: {
2194 ALOGV("AudioCommandThread() processing routing update");
2195 svc = mService.promote();
2196 if (svc == 0) {
2197 break;
2198 }
2199 mLock.unlock();
2200 svc->doOnRoutingUpdated();
2201 mLock.lock();
2202 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002203
Eric Laurented726cc2021-07-01 14:26:41 +02002204 case UPDATE_UID_STATES: {
2205 ALOGV("AudioCommandThread() processing updateUID states");
2206 svc = mService.promote();
2207 if (svc == 0) {
2208 break;
2209 }
2210 mLock.unlock();
2211 svc->updateUidStates();
2212 mLock.lock();
2213 } break;
2214
Eric Laurent15903592022-02-24 20:44:36 +01002215 case CHECK_SPATIALIZER_OUTPUT: {
2216 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002217 svc = mService.promote();
2218 if (svc == 0) {
2219 break;
2220 }
2221 mLock.unlock();
2222 svc->doOnCheckSpatializer();
2223 mLock.lock();
2224 } break;
2225
Eric Laurent15903592022-02-24 20:44:36 +01002226 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2227 ALOGV("AudioCommandThread() processing update spatializer tracks");
2228 svc = mService.promote();
2229 if (svc == 0) {
2230 break;
2231 }
2232 mLock.unlock();
2233 svc->doOnUpdateActiveSpatializerTracks();
2234 mLock.lock();
2235 } break;
2236
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002237 case VOL_RANGE_INIT_REQUEST: {
2238 ALOGV("AudioCommandThread() processing volume range init request");
2239 svc = mService.promote();
2240 if (svc == 0) {
2241 break;
2242 }
2243 mLock.unlock();
2244 svc->doOnVolumeRangeInitRequest();
2245 mLock.lock();
2246 } break;
2247
Mathias Agopian65ab4712010-07-14 17:59:35 -07002248 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002249 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002250 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002251 {
2252 Mutex::Autolock _l(command->mLock);
2253 if (command->mWaitStatus) {
2254 command->mWaitStatus = false;
2255 command->mCond.signal();
2256 }
2257 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002258 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002259 // release mLock before releasing strong reference on the service as
2260 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2261 // acquires mLock.
2262 mLock.unlock();
2263 svc.clear();
2264 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002265 } else {
2266 waitTime = mAudioCommands[0]->mTime - curTime;
2267 break;
2268 }
2269 }
Zach Janga754b4f2015-10-27 01:29:34 +00002270
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002271 // release delayed commands wake lock as many times as we made the queue is
2272 // empty during popping.
2273 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002274 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002275 }
2276
2277 // At this stage we have either an empty command queue or the first command in the queue
2278 // has a finite delay. So unless we are exiting it is safe to wait.
2279 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002280 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002281 if (waitTime == -1) {
2282 mWaitWorkCV.wait(mLock);
2283 } else {
2284 mWaitWorkCV.waitRelative(mLock, waitTime);
2285 }
Eric Laurent59a89232014-06-08 14:14:17 -07002286 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002287 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002288 // release delayed commands wake lock before quitting
2289 if (!mAudioCommands.isEmpty()) {
2290 release_wake_lock(mName.string());
2291 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002292 mLock.unlock();
2293 return false;
2294}
2295
2296status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2297{
2298 const size_t SIZE = 256;
2299 char buffer[SIZE];
2300 String8 result;
2301
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002302 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002303 if (!locked) {
2304 String8 result2(kCmdDeadlockedString);
2305 write(fd, result2.string(), result2.size());
2306 }
2307
2308 snprintf(buffer, SIZE, "- Commands:\n");
2309 result = String8(buffer);
2310 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002311 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002312 mAudioCommands[i]->dump(buffer, SIZE);
2313 result.append(buffer);
2314 }
2315 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002316 if (mLastCommand != 0) {
2317 mLastCommand->dump(buffer, SIZE);
2318 result.append(buffer);
2319 } else {
2320 result.append(" none\n");
2321 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002322
2323 write(fd, result.string(), result.size());
2324
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002325 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002326
2327 return NO_ERROR;
2328}
2329
Glenn Kastenfff6d712012-01-12 16:38:12 -08002330status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002331 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002332 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002333 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002334{
Eric Laurent0ede8922014-05-09 18:04:42 -07002335 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002336 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002337 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002338 data->mStream = stream;
2339 data->mVolume = volume;
2340 data->mIO = output;
2341 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002342 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002343 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002344 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002345 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002346}
2347
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002348status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002349 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002350 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002351{
Eric Laurent0ede8922014-05-09 18:04:42 -07002352 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002353 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002354 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002355 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002356 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002357 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002358 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002359 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002360 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002361 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002362}
2363
2364status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2365{
Eric Laurent0ede8922014-05-09 18:04:42 -07002366 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002367 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002368 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002369 data->mVolume = volume;
2370 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002371 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002372 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002373 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002374}
2375
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002376void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2377 audio_session_t sessionId,
2378 bool suspended)
2379{
2380 sp<AudioCommand> command = new AudioCommand();
2381 command->mCommand = SET_EFFECT_SUSPENDED;
2382 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2383 data->mEffectId = effectId;
2384 data->mSessionId = sessionId;
2385 data->mSuspended = suspended;
2386 command->mParam = data;
2387 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2388 effectId, sessionId, suspended);
2389 sendCommand(command);
2390}
2391
2392
Eric Laurentd7fe0862018-07-14 16:48:01 -07002393void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002394{
Eric Laurent0ede8922014-05-09 18:04:42 -07002395 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002396 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002397 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002398 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002399 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002400 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002401 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002402}
2403
Eric Laurentd7fe0862018-07-14 16:48:01 -07002404void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002405{
Eric Laurent0ede8922014-05-09 18:04:42 -07002406 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002407 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002408 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002409 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002410 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002411 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002412 sendCommand(command);
2413}
2414
Eric Laurent951f4552014-05-20 10:48:17 -07002415status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2416 const struct audio_patch *patch,
2417 audio_patch_handle_t *handle,
2418 int delayMs)
2419{
2420 status_t status = NO_ERROR;
2421
2422 sp<AudioCommand> command = new AudioCommand();
2423 command->mCommand = CREATE_AUDIO_PATCH;
2424 CreateAudioPatchData *data = new CreateAudioPatchData();
2425 data->mPatch = *patch;
2426 data->mHandle = *handle;
2427 command->mParam = data;
2428 command->mWaitStatus = true;
2429 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2430 status = sendCommand(command, delayMs);
2431 if (status == NO_ERROR) {
2432 *handle = data->mHandle;
2433 }
2434 return status;
2435}
2436
2437status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2438 int delayMs)
2439{
2440 sp<AudioCommand> command = new AudioCommand();
2441 command->mCommand = RELEASE_AUDIO_PATCH;
2442 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2443 data->mHandle = handle;
2444 command->mParam = data;
2445 command->mWaitStatus = true;
2446 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2447 return sendCommand(command, delayMs);
2448}
2449
Eric Laurentb52c1522014-05-20 11:27:36 -07002450void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2451{
2452 sp<AudioCommand> command = new AudioCommand();
2453 command->mCommand = UPDATE_AUDIOPORT_LIST;
2454 ALOGV("AudioCommandThread() adding update audio port list");
2455 sendCommand(command);
2456}
2457
Eric Laurented726cc2021-07-01 14:26:41 +02002458void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2459{
2460 sp<AudioCommand> command = new AudioCommand();
2461 command->mCommand = UPDATE_UID_STATES;
2462 ALOGV("AudioCommandThread() adding update UID states");
2463 sendCommand(command);
2464}
2465
Eric Laurentb52c1522014-05-20 11:27:36 -07002466void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2467{
2468 sp<AudioCommand>command = new AudioCommand();
2469 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2470 ALOGV("AudioCommandThread() adding update audio patch list");
2471 sendCommand(command);
2472}
2473
François Gaffiecfe17322018-11-07 13:41:29 +01002474void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2475 int flags)
2476{
2477 sp<AudioCommand>command = new AudioCommand();
2478 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2479 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2480 data->mGroup = group;
2481 data->mFlags = flags;
2482 command->mParam = data;
2483 ALOGV("AudioCommandThread() adding audio volume group changed");
2484 sendCommand(command);
2485}
2486
Eric Laurente1715a42014-05-20 11:30:42 -07002487status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2488 const struct audio_port_config *config, int delayMs)
2489{
2490 sp<AudioCommand> command = new AudioCommand();
2491 command->mCommand = SET_AUDIOPORT_CONFIG;
2492 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2493 data->mConfig = *config;
2494 command->mParam = data;
2495 command->mWaitStatus = true;
2496 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2497 return sendCommand(command, delayMs);
2498}
2499
Jean-Michel Trivide801052015-04-14 19:10:14 -07002500void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002501 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002502{
2503 sp<AudioCommand> command = new AudioCommand();
2504 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2505 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2506 data->mRegId = regId;
2507 data->mState = state;
2508 command->mParam = data;
2509 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2510 regId.string(), state);
2511 sendCommand(command);
2512}
2513
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002514void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002515 int event,
2516 const record_client_info_t *clientInfo,
2517 const audio_config_base_t *clientConfig,
2518 std::vector<effect_descriptor_t> clientEffects,
2519 const audio_config_base_t *deviceConfig,
2520 std::vector<effect_descriptor_t> effects,
2521 audio_patch_handle_t patchHandle,
2522 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002523{
2524 sp<AudioCommand>command = new AudioCommand();
2525 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2526 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2527 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002528 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002529 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002530 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002531 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002532 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002533 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002534 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002535 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002536 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2537 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002538 sendCommand(command);
2539}
2540
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002541void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2542{
2543 sp<AudioCommand> command = new AudioCommand();
2544 command->mCommand = AUDIO_MODULES_UPDATE;
2545 sendCommand(command);
2546}
2547
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002548void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2549{
2550 sp<AudioCommand>command = new AudioCommand();
2551 command->mCommand = ROUTING_UPDATED;
2552 ALOGV("AudioCommandThread() adding routing update");
2553 sendCommand(command);
2554}
2555
Eric Laurent81dd0f52021-07-05 11:54:40 +02002556void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2557{
2558 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002559 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002560 ALOGV("AudioCommandThread() adding check spatializer");
2561 sendCommand(command);
2562}
2563
Eric Laurent15903592022-02-24 20:44:36 +01002564void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2565{
2566 sp<AudioCommand>command = new AudioCommand();
2567 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2568 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2569 sendCommand(command);
2570}
2571
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002572void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2573{
2574 sp<AudioCommand>command = new AudioCommand();
2575 command->mCommand = VOL_RANGE_INIT_REQUEST;
2576 ALOGV("AudioCommandThread() adding volume range init request");
2577 sendCommand(command);
2578}
2579
Eric Laurent0ede8922014-05-09 18:04:42 -07002580status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2581{
2582 {
2583 Mutex::Autolock _l(mLock);
2584 insertCommand_l(command, delayMs);
2585 mWaitWorkCV.signal();
2586 }
2587 Mutex::Autolock _l(command->mLock);
2588 while (command->mWaitStatus) {
2589 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2590 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2591 command->mStatus = TIMED_OUT;
2592 command->mWaitStatus = false;
2593 }
2594 }
2595 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002596}
2597
Mathias Agopian65ab4712010-07-14 17:59:35 -07002598// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002599void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002600{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002601 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002602 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002603 command->mTime = systemTime() + milliseconds(delayMs);
2604
2605 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002606 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002607 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2608 }
2609
2610 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002611 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002612 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002613 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2614 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002615
2616 // create audio patch or release audio patch commands are equivalent
2617 // with regard to filtering
2618 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2619 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2620 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2621 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2622 continue;
2623 }
2624 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002625
2626 switch (command->mCommand) {
2627 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002628 ParametersData *data = (ParametersData *)command->mParam.get();
2629 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002630 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002631 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002632 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002633 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2634 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2635 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002636 String8 key;
2637 String8 value;
2638 param.getAt(j, key, value);
2639 for (size_t k = 0; k < param2.size(); k++) {
2640 String8 key2;
2641 String8 value2;
2642 param2.getAt(k, key2, value2);
2643 if (key2 == key) {
2644 param2.remove(key2);
2645 ALOGV("Filtering out parameter %s", key2.string());
2646 break;
2647 }
2648 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002649 }
2650 // if all keys have been filtered out, remove the command.
2651 // otherwise, update the key value pairs
2652 if (param2.size() == 0) {
2653 removedCommands.add(command2);
2654 } else {
2655 data2->mKeyValuePairs = param2.toString();
2656 }
Eric Laurent21e54562013-09-23 12:08:05 -07002657 command->mTime = command2->mTime;
2658 // force delayMs to non 0 so that code below does not request to wait for
2659 // command status as the command is now delayed
2660 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002661 } break;
2662
2663 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002664 VolumeData *data = (VolumeData *)command->mParam.get();
2665 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002666 if (data->mIO != data2->mIO) break;
2667 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002668 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002669 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002670 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002671 command->mTime = command2->mTime;
2672 // force delayMs to non 0 so that code below does not request to wait for
2673 // command status as the command is now delayed
2674 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002675 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002676
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002677 case SET_VOICE_VOLUME: {
2678 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2679 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2680 ALOGV("Filtering out voice volume command value %f replaced by %f",
2681 data2->mVolume, data->mVolume);
2682 removedCommands.add(command2);
2683 command->mTime = command2->mTime;
2684 // force delayMs to non 0 so that code below does not request to wait for
2685 // command status as the command is now delayed
2686 delayMs = 1;
2687 } break;
2688
Eric Laurente45b48a2014-09-04 16:40:57 -07002689 case CREATE_AUDIO_PATCH:
2690 case RELEASE_AUDIO_PATCH: {
2691 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002692 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002693 if (command->mCommand == CREATE_AUDIO_PATCH) {
2694 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002695 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002696 } else {
2697 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002698 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002699 }
2700 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002701 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002702 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2703 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002704 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002705 } else {
2706 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002707 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002708 }
2709 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002710 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2711 same output. */
2712 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2713 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2714 bool isOutputDiff = false;
2715 if (patch.num_sources == patch2.num_sources) {
2716 for (unsigned count = 0; count < patch.num_sources; count++) {
2717 if (patch.sources[count].id != patch2.sources[count].id) {
2718 isOutputDiff = true;
2719 break;
2720 }
2721 }
2722 if (isOutputDiff)
2723 break;
2724 }
2725 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002726 ALOGV("Filtering out %s audio patch command for handle %d",
2727 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2728 removedCommands.add(command2);
2729 command->mTime = command2->mTime;
2730 // force delayMs to non 0 so that code below does not request to wait for
2731 // command status as the command is now delayed
2732 delayMs = 1;
2733 } break;
2734
Jean-Michel Trivide801052015-04-14 19:10:14 -07002735 case DYN_POLICY_MIX_STATE_UPDATE: {
2736
2737 } break;
2738
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002739 case RECORDING_CONFIGURATION_UPDATE: {
2740
2741 } break;
2742
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002743 case ROUTING_UPDATED: {
2744
2745 } break;
2746
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002747 case VOL_RANGE_INIT_REQUEST: {
2748 // command may come from different requests, do not filter
2749 } break;
2750
Mathias Agopian65ab4712010-07-14 17:59:35 -07002751 default:
2752 break;
2753 }
2754 }
2755
2756 // remove filtered commands
2757 for (size_t j = 0; j < removedCommands.size(); j++) {
2758 // removed commands always have time stamps greater than current command
2759 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002760 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002761 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002762 mAudioCommands.removeAt(k);
2763 break;
2764 }
2765 }
2766 }
2767 removedCommands.clear();
2768
Eric Laurentaa79bef2015-01-15 14:33:51 -08002769 // Disable wait for status if delay is not 0.
2770 // Except for create audio patch command because the returned patch handle
2771 // is needed by audio policy manager
2772 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002773 command->mWaitStatus = false;
2774 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002775
Mathias Agopian65ab4712010-07-14 17:59:35 -07002776 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002777 ALOGV("inserting command: %d at index %zd, num commands %zu",
2778 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002779 mAudioCommands.insertAt(command, i + 1);
2780}
2781
2782void AudioPolicyService::AudioCommandThread::exit()
2783{
Steve Block3856b092011-10-20 11:56:00 +01002784 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002785 {
2786 AutoMutex _l(mLock);
2787 requestExit();
2788 mWaitWorkCV.signal();
2789 }
Zach Janga754b4f2015-10-27 01:29:34 +00002790 // Note that we can call it from the thread loop if all other references have been released
2791 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002792 requestExitAndWait();
2793}
2794
2795void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2796{
2797 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2798 mCommand,
2799 (int)ns2s(mTime),
2800 (int)ns2ms(mTime)%1000,
2801 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002802 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002803}
2804
Dima Zavinfce7a472011-04-19 22:30:36 -07002805/******* helpers for the service_ops callbacks defined below *********/
2806void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2807 const char *keyValuePairs,
2808 int delayMs)
2809{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002810 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002811 delayMs);
2812}
2813
2814int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2815 float volume,
2816 audio_io_handle_t output,
2817 int delayMs)
2818{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002819 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002820 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002821}
2822
Dima Zavinfce7a472011-04-19 22:30:36 -07002823int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2824{
2825 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2826}
2827
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002828void AudioPolicyService::setEffectSuspended(int effectId,
2829 audio_session_t sessionId,
2830 bool suspended)
2831{
2832 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2833}
2834
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002835Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002836{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002837 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002838 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002839}
2840
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002841
Dima Zavinfce7a472011-04-19 22:30:36 -07002842extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002843audio_module_handle_t aps_load_hw_module(void *service __unused,
2844 const char *name);
2845audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002846 audio_devices_t *pDevices,
2847 uint32_t *pSamplingRate,
2848 audio_format_t *pFormat,
2849 audio_channel_mask_t *pChannelMask,
2850 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002851 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002852
Eric Laurent2d388ec2014-03-07 13:25:54 -08002853audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002854 audio_module_handle_t module,
2855 audio_devices_t *pDevices,
2856 uint32_t *pSamplingRate,
2857 audio_format_t *pFormat,
2858 audio_channel_mask_t *pChannelMask,
2859 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002860 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002861 const audio_offload_info_t *offloadInfo);
2862audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002863 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002864 audio_io_handle_t output2);
2865int aps_close_output(void *service __unused, audio_io_handle_t output);
2866int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2867int aps_restore_output(void *service __unused, audio_io_handle_t output);
2868audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002869 audio_devices_t *pDevices,
2870 uint32_t *pSamplingRate,
2871 audio_format_t *pFormat,
2872 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002873 audio_in_acoustics_t acoustics __unused);
2874audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002875 audio_module_handle_t module,
2876 audio_devices_t *pDevices,
2877 uint32_t *pSamplingRate,
2878 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002879 audio_channel_mask_t *pChannelMask);
2880int aps_close_input(void *service __unused, audio_io_handle_t input);
2881int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002882int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002883 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002884 audio_io_handle_t dst_output);
2885char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2886 const char *keys);
2887void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2888 const char *kv_pairs, int delay_ms);
2889int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002890 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002891 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002892int aps_set_voice_volume(void *service, float volume, int delay_ms);
2893};
Dima Zavinfce7a472011-04-19 22:30:36 -07002894
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002895} // namespace android