blob: 6fd2ccd94d5ee92bc6968e3d7e815f5bc2a084a3 [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>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053049#include <AudioPolicyManager.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070050
Mathias Agopian65ab4712010-07-14 17:59:35 -070051namespace android {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080052using binder::Status;
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
Glenn Kasten8dad0e32012-01-09 08:41:22 -080054static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
55static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053056static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
Mathias Agopian65ab4712010-07-14 17:59:35 -070057
Mikhail Naganov959e2d02019-03-28 11:08:19 -070058static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Mathias Agopian65ab4712010-07-14 17:59:35 -070059
Eric Laurent0ede8922014-05-09 18:04:42 -070060static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010061
Svet Ganovf4ddfef2018-01-16 07:37:58 -080062static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070063
Andy Hungc747c532022-03-07 21:41:14 -080064// Creates an association between Binder code to name for IAudioPolicyService.
65#define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
66BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
67BINDER_METHOD_ENTRY(setDeviceConnectionState) \
68BINDER_METHOD_ENTRY(getDeviceConnectionState) \
69BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
70BINDER_METHOD_ENTRY(setPhoneState) \
71BINDER_METHOD_ENTRY(setForceUse) \
72BINDER_METHOD_ENTRY(getForceUse) \
73BINDER_METHOD_ENTRY(getOutput) \
74BINDER_METHOD_ENTRY(getOutputForAttr) \
75BINDER_METHOD_ENTRY(startOutput) \
76BINDER_METHOD_ENTRY(stopOutput) \
77BINDER_METHOD_ENTRY(releaseOutput) \
78BINDER_METHOD_ENTRY(getInputForAttr) \
79BINDER_METHOD_ENTRY(startInput) \
80BINDER_METHOD_ENTRY(stopInput) \
81BINDER_METHOD_ENTRY(releaseInput) \
82BINDER_METHOD_ENTRY(initStreamVolume) \
83BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
84BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
85BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
86BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
87BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
88BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getStrategyForStream) \
90BINDER_METHOD_ENTRY(getDevicesForAttributes) \
91BINDER_METHOD_ENTRY(getOutputForEffect) \
92BINDER_METHOD_ENTRY(registerEffect) \
93BINDER_METHOD_ENTRY(unregisterEffect) \
94BINDER_METHOD_ENTRY(setEffectEnabled) \
95BINDER_METHOD_ENTRY(moveEffectsToIo) \
96BINDER_METHOD_ENTRY(isStreamActive) \
97BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
98BINDER_METHOD_ENTRY(isSourceActive) \
99BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
100BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
101BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
102BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
103BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
104BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
105BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
106BINDER_METHOD_ENTRY(getOffloadSupport) \
107BINDER_METHOD_ENTRY(isDirectOutputSupported) \
108BINDER_METHOD_ENTRY(listAudioPorts) \
109BINDER_METHOD_ENTRY(getAudioPort) \
110BINDER_METHOD_ENTRY(createAudioPatch) \
111BINDER_METHOD_ENTRY(releaseAudioPatch) \
112BINDER_METHOD_ENTRY(listAudioPatches) \
113BINDER_METHOD_ENTRY(setAudioPortConfig) \
114BINDER_METHOD_ENTRY(registerClient) \
115BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
116BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
117BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
118BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
119BINDER_METHOD_ENTRY(getPhoneState) \
120BINDER_METHOD_ENTRY(registerPolicyMixes) \
121BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
122BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
123BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
124BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
125BINDER_METHOD_ENTRY(startAudioSource) \
126BINDER_METHOD_ENTRY(stopAudioSource) \
127BINDER_METHOD_ENTRY(setMasterMono) \
128BINDER_METHOD_ENTRY(getMasterMono) \
129BINDER_METHOD_ENTRY(getStreamVolumeDB) \
130BINDER_METHOD_ENTRY(getSurroundFormats) \
131BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
132BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
133BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
134BINDER_METHOD_ENTRY(setAssistantServicesUids) \
135BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
136BINDER_METHOD_ENTRY(setA11yServicesUids) \
137BINDER_METHOD_ENTRY(setCurrentImeUid) \
138BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
139BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800140BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800141BINDER_METHOD_ENTRY(listAudioProductStrategies) \
142BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
143BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
144BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
145BINDER_METHOD_ENTRY(setRttEnabled) \
146BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
147BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
148BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000149BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800150BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
151BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
152BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
156BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
157BINDER_METHOD_ENTRY(getSpatializer) \
158BINDER_METHOD_ENTRY(canBeSpatialized) \
159BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000160BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
161BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
162BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
163BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
164BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800165
166// singleton for Binder Method Statistics for IAudioPolicyService
167static auto& getIAudioPolicyServiceStatistics() {
168 using Code = int;
169
170#pragma push_macro("BINDER_METHOD_ENTRY")
171#undef BINDER_METHOD_ENTRY
172#define BINDER_METHOD_ENTRY(ENTRY) \
173 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
174
175 static mediautils::MethodStatistics<Code> methodStatistics{
176 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
177 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
178 };
179#pragma pop_macro("BINDER_METHOD_ENTRY")
180
181 return methodStatistics;
182}
183
Mathias Agopian65ab4712010-07-14 17:59:35 -0700184// ----------------------------------------------------------------------------
185
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530186static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
187{
188 AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);
189 status_t status = apm->initialize();
190 if (status != NO_ERROR) {
191 delete apm;
192 apm = nullptr;
193 }
194 return apm;
195}
196
197static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
198{
199 delete interface;
200}
201// ----------------------------------------------------------------------------
202
Mathias Agopian65ab4712010-07-14 17:59:35 -0700203AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700204 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700205 mAudioPolicyManager(NULL),
206 mAudioPolicyClient(NULL),
207 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530208 mCaptureStateNotifier(false),
209 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100210 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
211 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800212 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530213}
214
215void AudioPolicyService::loadAudioPolicyManager()
216{
217 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
218 if (mLibraryHandle != nullptr) {
219 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
220 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
221 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
222 const char *lastError = dlerror();
223 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
224 __func__, lastError != nullptr ? lastError : "no error");
225
226 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
227 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
228 lastError = dlerror();
229 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
230 __func__, lastError != nullptr ? lastError : "no error");
231 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
232 unloadAudioPolicyManager();
233 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
234 }
235 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700236}
237
238void AudioPolicyService::onFirstRef()
239{
Andy Hungd47aca22022-03-15 11:50:51 -0700240 // Log an AudioPolicy "constructor" mediametrics event on first ref.
241 // This records the time it takes to load the audio modules and devices.
242 mediametrics::Defer defer([beginNs = systemTime()] {
243 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
244 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
245 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
246 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700247 {
248 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800249
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700250 // start audio commands thread
251 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
252 // start output activity command thread
253 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700254
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700255 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530256
257 loadAudioPolicyManager();
258 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700259 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200260
bryant_liuba2b4392014-06-11 16:49:30 +0800261 // load audio processing modules
Sebastian Pickl30c8c362023-04-21 08:29:27 +0000262 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000263 sp<UidPolicy> uidPolicy = new UidPolicy(this);
264 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700265 {
266 Mutex::Autolock _l(mLock);
267 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000268 mUidPolicy = uidPolicy;
269 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700270 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000271 uidPolicy->registerSelf();
272 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200273
Eric Laurent81dd0f52021-07-05 11:54:40 +0200274 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200275 if (mAudioPolicyManager != nullptr) {
276 Mutex::Autolock _l(mLock);
277 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
278 AudioDeviceTypeAddrVector devices;
279 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
280 if (hasSpatializer) {
Sebastian Pickl30c8c362023-04-21 08:29:27 +0000281 mSpatializer = Spatializer::create(this);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200282 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700283 if (mSpatializer == nullptr) {
284 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
285 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
286 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
287 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200288 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200289 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700290}
291
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530292void AudioPolicyService::unloadAudioPolicyManager()
293{
294 ALOGV("%s ", __func__);
295 if (mLibraryHandle != nullptr) {
296 dlclose(mLibraryHandle);
297 }
298 mLibraryHandle = nullptr;
299 mCreateAudioPolicyManager = nullptr;
300 mDestroyAudioPolicyManager = nullptr;
301}
302
Mathias Agopian65ab4712010-07-14 17:59:35 -0700303AudioPolicyService::~AudioPolicyService()
304{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700305 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700306 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700307
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530308 mDestroyAudioPolicyManager(mAudioPolicyManager);
309 unloadAudioPolicyManager();
310
Eric Laurentdce54a12014-03-10 12:19:46 -0700311 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700312
313 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800314 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800315
316 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800317 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000318
319 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800320 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700321}
322
323// A notification client is always registered by AudioSystem when the client process
324// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800325Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700326{
Eric Laurent12590252015-08-21 18:40:20 -0700327 if (client == 0) {
328 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800329 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700330 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800331 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700332
333 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800334 pid_t pid = IPCThreadState::self()->getCallingPid();
335 int64_t token = ((int64_t)uid<<32) | pid;
336
337 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700338 sp<NotificationClient> notificationClient = new NotificationClient(this,
339 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800340 uid,
341 pid);
342 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700343
luochaojiang908c7d72018-06-21 14:58:04 +0800344 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700345
Marco Nelissenf8880202014-11-14 07:58:25 -0800346 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700347 binder->linkToDeath(notificationClient);
348 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800349 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700350}
351
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800352Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700353{
354 Mutex::Autolock _l(mNotificationClientsLock);
355
356 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800357 pid_t pid = IPCThreadState::self()->getCallingPid();
358 int64_t token = ((int64_t)uid<<32) | pid;
359
360 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800361 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700362 }
luochaojiang908c7d72018-06-21 14:58:04 +0800363 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800364 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700365}
366
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800367Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100368{
369 Mutex::Autolock _l(mNotificationClientsLock);
370
371 uid_t uid = IPCThreadState::self()->getCallingUid();
372 pid_t pid = IPCThreadState::self()->getCallingPid();
373 int64_t token = ((int64_t)uid<<32) | pid;
374
375 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800376 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100377 }
378 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800379 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100380}
381
Eric Laurentb52c1522014-05-20 11:27:36 -0700382// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800383void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700384{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000385 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800386 {
387 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800388 int64_t token = ((int64_t)uid<<32) | pid;
389 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800390 for (size_t i = 0; i < mNotificationClients.size(); i++) {
391 if (mNotificationClients.valueAt(i)->uid() == uid) {
392 hasSameUid = true;
393 break;
394 }
395 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000396 }
397 {
398 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800399 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700400 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700401 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700402 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800403 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700404}
405
406void AudioPolicyService::onAudioPortListUpdate()
407{
408 mOutputCommandThread->updateAudioPortListCommand();
409}
410
411void AudioPolicyService::doOnAudioPortListUpdate()
412{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800413 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700414 for (size_t i = 0; i < mNotificationClients.size(); i++) {
415 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
416 }
417}
418
419void AudioPolicyService::onAudioPatchListUpdate()
420{
421 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700422}
423
Eric Laurentb52c1522014-05-20 11:27:36 -0700424void AudioPolicyService::doOnAudioPatchListUpdate()
425{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800426 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700427 for (size_t i = 0; i < mNotificationClients.size(); i++) {
428 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
429 }
430}
431
François Gaffiecfe17322018-11-07 13:41:29 +0100432void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
433{
434 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
435}
436
437void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
438{
439 Mutex::Autolock _l(mNotificationClientsLock);
440 for (size_t i = 0; i < mNotificationClients.size(); i++) {
441 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
442 }
443}
444
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700445void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700446{
447 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
448 regId.string(), state);
449 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
450}
451
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700452void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700453{
454 Mutex::Autolock _l(mNotificationClientsLock);
455 for (size_t i = 0; i < mNotificationClients.size(); i++) {
456 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
457 }
458}
459
Eric Laurenta9f86652018-11-28 17:23:11 -0800460void AudioPolicyService::onRecordingConfigurationUpdate(
461 int event,
462 const record_client_info_t *clientInfo,
463 const audio_config_base_t *clientConfig,
464 std::vector<effect_descriptor_t> clientEffects,
465 const audio_config_base_t *deviceConfig,
466 std::vector<effect_descriptor_t> effects,
467 audio_patch_handle_t patchHandle,
468 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800469{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800470 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800471 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800472}
473
Eric Laurenta9f86652018-11-28 17:23:11 -0800474void AudioPolicyService::doOnRecordingConfigurationUpdate(
475 int event,
476 const record_client_info_t *clientInfo,
477 const audio_config_base_t *clientConfig,
478 std::vector<effect_descriptor_t> clientEffects,
479 const audio_config_base_t *deviceConfig,
480 std::vector<effect_descriptor_t> effects,
481 audio_patch_handle_t patchHandle,
482 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800483{
484 Mutex::Autolock _l(mNotificationClientsLock);
485 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800486 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800487 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800488 }
489}
490
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700491void AudioPolicyService::onRoutingUpdated()
492{
493 mOutputCommandThread->routingChangedCommand();
494}
495
496void AudioPolicyService::doOnRoutingUpdated()
497{
498 Mutex::Autolock _l(mNotificationClientsLock);
499 for (size_t i = 0; i < mNotificationClients.size(); i++) {
500 mNotificationClients.valueAt(i)->onRoutingUpdated();
501 }
502}
503
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000504void AudioPolicyService::onVolumeRangeInitRequest()
505{
506 mOutputCommandThread->volRangeInitReqCommand();
507}
508
509void AudioPolicyService::doOnVolumeRangeInitRequest()
510{
511 Mutex::Autolock _l(mNotificationClientsLock);
512 for (size_t i = 0; i < mNotificationClients.size(); i++) {
513 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
514 }
515}
516
Eric Laurent81dd0f52021-07-05 11:54:40 +0200517void AudioPolicyService::onCheckSpatializer()
518{
519 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200520 onCheckSpatializer_l();
521}
522
523void AudioPolicyService::onCheckSpatializer_l()
524{
525 if (mSpatializer != nullptr) {
526 mOutputCommandThread->checkSpatializerCommand();
527 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200528}
529
530void AudioPolicyService::doOnCheckSpatializer()
531{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200532 ALOGV("%s mSpatializer %p level %d",
533 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200534
Eric Laurent39095982021-08-24 18:29:27 +0200535 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200536 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200537 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
538 audio_io_handle_t currentOutput = mSpatializer->getOutput();
539 audio_io_handle_t newOutput;
540 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
541 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200542
543 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200544 status_t status =
545 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100546 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
547 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200548 if (status == NO_ERROR && currentOutput == newOutput) {
549 return;
550 }
Eric Laurent15903592022-02-24 20:44:36 +0100551 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200552 mLock.unlock();
553 // It is OK to call detachOutput() is none is already attached.
554 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200555 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
556 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200557 }
Eric Laurent39095982021-08-24 18:29:27 +0200558 mLock.lock();
559 if (status != NO_ERROR) {
560 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
561 }
562 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
563 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200564 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200565
Eric Laurent39095982021-08-24 18:29:27 +0200566 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200567 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200568 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200569 }
570 }
571 }
572}
573
Eric Laurent11094172022-04-05 18:27:42 +0200574size_t AudioPolicyService::countActiveClientsOnOutput_l(
575 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100576 size_t count = 0;
577 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
578 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200579 if (client->io == output && client->active
580 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100581 count++;
582 }
583 }
584 return count;
585}
586
587void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
588 if (mSpatializer == nullptr) {
589 return;
590 }
591 mOutputCommandThread->updateActiveSpatializerTracksCommand();
592}
593
594void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
595{
Eric Laurent21270b62022-07-04 15:11:29 +0200596 if (mSpatializer == nullptr) {
597 return;
598 }
599 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200600 size_t activeClients;
601 {
602 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200603 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100604 }
Eric Laurent21270b62022-07-04 15:11:29 +0200605 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100606}
607
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800608status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
609 audio_patch_handle_t *handle,
610 int delayMs)
611{
612 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
613}
614
615status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
616 int delayMs)
617{
618 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
619}
620
Eric Laurente1715a42014-05-20 11:30:42 -0700621status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
622 int delayMs)
623{
624 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
625}
626
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800627AudioPolicyService::NotificationClient::NotificationClient(
628 const sp<AudioPolicyService>& service,
629 const sp<media::IAudioPolicyServiceClient>& client,
630 uid_t uid,
631 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800632 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100633 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700634{
635}
636
637AudioPolicyService::NotificationClient::~NotificationClient()
638{
639}
640
641void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
642{
643 sp<NotificationClient> keep(this);
644 sp<AudioPolicyService> service = mService.promote();
645 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800646 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700647 }
648}
649
650void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
651{
Eric Laurente8726fe2015-06-26 09:39:24 -0700652 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700653 mAudioPolicyServiceClient->onAudioPortListUpdate();
654 }
655}
656
657void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
658{
Eric Laurente8726fe2015-06-26 09:39:24 -0700659 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700660 mAudioPolicyServiceClient->onAudioPatchListUpdate();
661 }
662}
Eric Laurent57dae992011-07-24 13:36:09 -0700663
Pattydd807582021-11-04 21:01:03 +0800664void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100665 int flags)
666{
667 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
668 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
669 }
670}
671
672
Jean-Michel Trivide801052015-04-14 19:10:14 -0700673void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700674 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700675{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700676 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800677 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
678 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800679 }
680}
681
682void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800683 int event,
684 const record_client_info_t *clientInfo,
685 const audio_config_base_t *clientConfig,
686 std::vector<effect_descriptor_t> clientEffects,
687 const audio_config_base_t *deviceConfig,
688 std::vector<effect_descriptor_t> effects,
689 audio_patch_handle_t patchHandle,
690 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800691{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700692 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800693 status_t status = [&]() -> status_t {
694 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
695 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
696 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700697 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700698 legacy2aidl_audio_config_base_t_AudioConfigBase(
699 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800700 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
701 convertContainer<std::vector<media::EffectDescriptor>>(
702 clientEffects,
703 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700704 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700705 legacy2aidl_audio_config_base_t_AudioConfigBase(
706 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800707 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
708 convertContainer<std::vector<media::EffectDescriptor>>(
709 effects,
710 legacy2aidl_effect_descriptor_t_EffectDescriptor));
711 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
712 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700713 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
714 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800715 return aidl_utils::statusTFromBinderStatus(
716 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
717 clientInfoAidl,
718 clientConfigAidl,
719 clientEffectsAidl,
720 deviceConfigAidl,
721 effectsAidl,
722 patchHandleAidl,
723 sourceAidl));
724 }();
725 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700726 }
727}
728
Eric Laurente8726fe2015-06-26 09:39:24 -0700729void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
730{
731 mAudioPortCallbacksEnabled = enabled;
732}
733
François Gaffiecfe17322018-11-07 13:41:29 +0100734void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
735{
736 mAudioVolumeGroupCallbacksEnabled = enabled;
737}
Eric Laurente8726fe2015-06-26 09:39:24 -0700738
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700739void AudioPolicyService::NotificationClient::onRoutingUpdated()
740{
741 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
742 mAudioPolicyServiceClient->onRoutingUpdated();
743 }
744}
745
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000746void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
747{
748 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
749 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
750 }
751}
752
Mathias Agopian65ab4712010-07-14 17:59:35 -0700753void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700754 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700755 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700756}
757
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000758static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700759{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000760 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
761}
762
763static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
764{
765 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700766}
767
768status_t AudioPolicyService::dumpInternals(int fd)
769{
770 const size_t SIZE = 256;
771 char buffer[SIZE];
772 String8 result;
773
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000774 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800775 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000776 std::stringstream msg;
777 size_t i = 0;
778 for (auto usage : mSupportedSystemUsages) {
779 if (i++ != 0) msg << ", ";
780 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
781 msg << strUsage;
782 } else {
783 msg << usage << " (unknown)";
784 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800785 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000786 if (i == 0) {
787 msg << "None";
788 }
789 msg << std::endl;
790 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800791
Mathias Agopian65ab4712010-07-14 17:59:35 -0700792 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800793
794 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700795 return NO_ERROR;
796}
797
Eric Laurente8c8b432018-10-17 10:08:02 -0700798void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800799{
Eric Laurente8c8b432018-10-17 10:08:02 -0700800 Mutex::Autolock _l(mLock);
801 updateUidStates_l();
802}
803
804void AudioPolicyService::updateUidStates_l()
805{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800806// Go over all active clients and allow capture (does not force silence) in the
807// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800808// The client is in the active assistant list
809// AND is TOP
810// AND an accessibility service is TOP
811// AND source is either VOICE_RECOGNITION OR HOTWORD
812// OR there is no active privacy sensitive capture or call
813// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
814// AND source is VOICE_RECOGNITION OR HOTWORD
815// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800816// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700817// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800818// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800819// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800820// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
821// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800822// OR The client is an accessibility service
823// AND Is on TOP
824// AND the source is VOICE_RECOGNITION or HOTWORD
825// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700826// AND there is no active privacy sensitive capture or call
827// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800828// AND is on TOP
829// AND the source is VOICE_RECOGNITION or HOTWORD
830// OR the client source is virtual (remote submix, call audio TX or RX...)
831// OR the client source is HOTWORD
832// AND is on TOP
833// OR all active clients are using HOTWORD source
834// AND no call is active
835// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
836// OR the client is the current InputMethodService
837// AND a RTT call is active AND the source is VOICE_RECOGNITION
838// OR Any client
839// AND The assistant is not on TOP
840// AND is on TOP or latest started
841// AND there is no active privacy sensitive capture or call
842// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800843
Eric Laurent4e947da2019-10-17 15:24:06 -0700844
Eric Laurent4eb58f12018-12-07 16:41:02 -0800845 sp<AudioRecordClient> topActive;
846 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800847 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700848 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800849 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700850
Eric Laurenta46bedb2018-12-07 18:01:26 -0800851 nsecs_t topStartNs = 0;
852 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800853 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800854 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800855 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800856 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
857 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800858 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800859 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700860 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800861 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
862 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700863 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700864 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700865 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800866
Michael Groovercfd28302018-12-11 19:16:46 -0800867 // if Sensor Privacy is enabled then all recordings should be silenced.
868 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
869 silenceAllRecordings_l();
870 return;
871 }
872
Eric Laurente8c8b432018-10-17 10:08:02 -0700873 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
874 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000875 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
876 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800877 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700878 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800879 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700880
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700881 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700882 // clients which app is in IDLE state are not eligible for top active or
883 // latest active
884 if (appState == APP_STATE_IDLE) {
885 continue;
886 }
887
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700888 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700889 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800890 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700891 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700892 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800893 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800894 bool isPrivacySensitive =
895 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700896
Eric Laurentc21d5692020-02-25 10:24:36 -0800897 if (appState == APP_STATE_TOP) {
898 if (isPrivacySensitive) {
899 if (current->startTimeNs > topSensitiveStartNs) {
900 topSensitiveActive = current;
901 topSensitiveStartNs = current->startTimeNs;
902 }
903 } else {
904 if (current->startTimeNs > topStartNs) {
905 topActive = current;
906 topStartNs = current->startTimeNs;
907 }
908 }
909 if (isAssistant) {
910 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800911 if (isActiveAssistant) {
912 useActiveAssistantList = true;
913 } else if (!useActiveAssistantList) {
914 if (current->startTimeNs > latestAssistantStartNs) {
915 latestActiveAssistant = current;
916 latestAssistantStartNs = current->startTimeNs;
917 }
918 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800919 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800920 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800921 // Clients capturing for HOTWORD are not considered
922 // for latest active to avoid masking regular clients started before
923 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
924 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
925 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700926 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
927 // is marked latest sensitive active even if another app qualifies.
928 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700929 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700930 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700931 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000932 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700933 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700934 latestSensitiveActiveOrComm = current;
935 latestSensitiveStartNs = current->startTimeNs;
936 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800937 }
938 isSensitiveActive = true;
939 } else {
940 if (current->startTimeNs > latestStartNs) {
941 latestActive = current;
942 latestStartNs = current->startTimeNs;
943 }
944 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800945 }
946 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700947 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
948 onlyHotwordActive = false;
949 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100950 if (currentUid == mPhoneStateOwnerUid &&
951 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700952 isPhoneStateOwnerActive = true;
953 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800954 }
955
Eric Laurent1ff16a72019-03-14 18:35:04 -0700956 // if no active client with UI on Top, consider latest active as top
957 if (topActive == nullptr) {
958 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800959 topStartNs = latestStartNs;
960 }
961 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700962 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800963 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700964 } else if (latestSensitiveActiveOrComm != nullptr) {
965 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
966 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700967 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000968 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700969 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700970 topSensitiveActive = latestSensitiveActiveOrComm;
971 topSensitiveStartNs = latestSensitiveStartNs;
972 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800973 }
974
975 // If both privacy sensitive and regular capture are active:
976 // if the regular capture is privileged
977 // allow concurrency
978 // else
979 // favor the privacy sensitive case
980 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700981 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800982 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800983 }
984
985 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
986 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700987 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000988 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700989 if (!current->active) {
990 continue;
991 }
992
Eric Laurent4eb58f12018-12-07 16:41:02 -0800993 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700994 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000995 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700996 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000997 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800998 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
999 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001000
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001001 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001002 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001003 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001004 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001005 bool canCaptureCommunication = recordClient->canCaptureOutput
1006 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001007 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001008 return !(isInCall && !canCaptureCall)
1009 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001010 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001011
1012 // By default allow capture if:
1013 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001014 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001015 // AND there is no active privacy sensitive capture or call
1016 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001017 bool allowSensitiveCapture =
1018 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001019 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001020 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001021 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001022 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001023
Eric Laurented726cc2021-07-01 14:26:41 +02001024 if (!current->hasOp()) {
1025 // Never allow capture if app op is denied
1026 allowCapture = false;
1027 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001028 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1029 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001030 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001031 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001032 // Active assistant list is not being used
1033 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001034 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001035 // OR there is no active privacy sensitive capture or call
1036 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1037 // AND is latest TOP assistant AND
1038 // uses VOICE_RECOGNITION OR uses HOTWORD
1039 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001040 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001041 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001042 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001043 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001044 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001045 && canCaptureIfInCallOrCommunication(current)) {
1046 if (isTopOrLatestAssistant
1047 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1048 || source == AUDIO_SOURCE_HOTWORD)) {
1049 allowCapture = true;
1050 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1051 allowCapture = true;
1052 }
1053 }
1054 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1055 // For assistant on active list and on top allow capture if:
1056 // An accessibility service is on TOP
1057 // AND the source is VOICE_RECOGNITION or HOTWORD
1058 // OR there is no active privacy sensitive capture or call
1059 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1060 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1061 if (isA11yOnTop) {
1062 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1063 allowCapture = true;
1064 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001065 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001066 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001067 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1068 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001069 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001070 }
1071 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001072 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001073 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001074 // The assistant is not on TOP
1075 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001076 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001077 // OR
1078 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1079 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001080 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001081 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001082 allowCapture = true;
1083 }
Eric Laurent589171c2019-07-25 18:04:29 -07001084 if (isA11yOnTop) {
1085 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1086 allowCapture = true;
1087 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001088 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001089 } else if (source == AUDIO_SOURCE_HOTWORD) {
1090 // For HOTWORD source allow capture when not on TOP if:
1091 // All active clients are using HOTWORD source
1092 // AND no call is active
1093 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001094 if (onlyHotwordActive
1095 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001096 allowCapture = true;
1097 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001098 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001099 // For current InputMethodService allow capture if:
1100 // A RTT call is active AND the source is VOICE_RECOGNITION
1101 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1102 allowCapture = true;
1103 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001104 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001105 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001106 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001107 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001108 }
1109}
1110
Michael Groovercfd28302018-12-11 19:16:46 -08001111void AudioPolicyService::silenceAllRecordings_l() {
1112 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1113 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001114 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001115 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001116 }
Michael Groovercfd28302018-12-11 19:16:46 -08001117 }
1118}
1119
Eric Laurente8c8b432018-10-17 10:08:02 -07001120/* static */
1121app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001122
1123 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001124 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001125 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1126 // include persistent services
1127 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001128 }
1129 return APP_STATE_FOREGROUND;
1130}
1131
Eric Laurent4eb58f12018-12-07 16:41:02 -08001132/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001133bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001134{
1135 switch (source) {
1136 case AUDIO_SOURCE_VOICE_UPLINK:
1137 case AUDIO_SOURCE_VOICE_DOWNLINK:
1138 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001139 case AUDIO_SOURCE_REMOTE_SUBMIX:
1140 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001141 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001142 return true;
1143 default:
1144 break;
1145 }
1146 return false;
1147}
1148
Eric Laurented726cc2021-07-01 14:26:41 +02001149/* static */
1150bool AudioPolicyService::isAppOpSource(audio_source_t source)
1151{
1152 switch (source) {
1153 case AUDIO_SOURCE_FM_TUNER:
1154 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001155 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001156 return false;
1157 default:
1158 break;
1159 }
1160 return true;
1161}
1162
Eric Laurent8c7ef892021-06-10 13:32:16 +02001163void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001164{
1165 AutoCallerClear acc;
1166
1167 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001168 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001169 }
1170 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1171 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001172 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001173 if (client->silenced != silenced) {
1174 if (client->active) {
1175 if (silenced) {
1176 finishRecording(client->attributionSource, client->attributes.source);
1177 } else {
1178 std::stringstream msg;
1179 msg << "Audio recording un-silenced on session " << client->session;
1180 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1181 client->attributes.source)) {
1182 silenced = true;
1183 }
1184 }
1185 }
1186 af->setRecordSilenced(client->portId, silenced);
1187 client->silenced = silenced;
1188 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001189 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001190}
1191
Glenn Kasten0f11b512014-01-31 16:18:54 -08001192status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001193{
Glenn Kasten44deb052012-02-05 18:09:08 -08001194 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001195 dumpPermissionDenial(fd);
1196 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001197 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001198 if (!locked) {
1199 String8 result(kDeadlockedString);
1200 write(fd, result.string(), result.size());
1201 }
1202
1203 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001204
1205 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1206 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001207 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001208 mAudioCommandThread->dump(fd);
1209 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001210
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001211 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1212 write(fd, octPtr.string(), octPtr.size());
1213 if (mOutputCommandThread != 0) {
1214 mOutputCommandThread->dump(fd);
1215 }
1216
Eric Laurentdce54a12014-03-10 12:19:46 -07001217 if (mAudioPolicyManager) {
1218 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001219 } else {
1220 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1221 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001222 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001223
Kevin Rocard8be94972019-02-22 13:26:25 -08001224 mPackageManager.dump(fd);
1225
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001226 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001227
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001228 if (mSpatializer != nullptr) {
1229 std::string dumpString = mSpatializer->toString(1 /* level */);
1230 write(fd, dumpString.c_str(), dumpString.size());
1231 } else {
1232 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1233 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1234 }
1235
Andy Hungc747c532022-03-07 21:41:14 -08001236 {
1237 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1238 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1239 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1240 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001241 }
1242 return NO_ERROR;
1243}
1244
1245status_t AudioPolicyService::dumpPermissionDenial(int fd)
1246{
1247 const size_t SIZE = 256;
1248 char buffer[SIZE];
1249 String8 result;
1250 snprintf(buffer, SIZE, "Permission Denial: "
1251 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1252 IPCThreadState::self()->getCallingPid(),
1253 IPCThreadState::self()->getCallingUid());
1254 result.append(buffer);
1255 write(fd, result.string(), result.size());
1256 return NO_ERROR;
1257}
1258
1259status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001260 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001261 // make sure transactions reserved to AudioFlinger do not come from other processes
1262 switch (code) {
1263 case TRANSACTION_startOutput:
1264 case TRANSACTION_stopOutput:
1265 case TRANSACTION_releaseOutput:
1266 case TRANSACTION_getInputForAttr:
1267 case TRANSACTION_startInput:
1268 case TRANSACTION_stopInput:
1269 case TRANSACTION_releaseInput:
1270 case TRANSACTION_getOutputForEffect:
1271 case TRANSACTION_registerEffect:
1272 case TRANSACTION_unregisterEffect:
1273 case TRANSACTION_setEffectEnabled:
1274 case TRANSACTION_getStrategyForStream:
1275 case TRANSACTION_getOutputForAttr:
1276 case TRANSACTION_moveEffectsToIo:
1277 ALOGW("%s: transaction %d received from PID %d",
1278 __func__, code, IPCThreadState::self()->getCallingPid());
1279 return INVALID_OPERATION;
1280 default:
1281 break;
1282 }
1283
1284 // make sure the following transactions come from system components
1285 switch (code) {
1286 case TRANSACTION_setDeviceConnectionState:
1287 case TRANSACTION_handleDeviceConfigChange:
1288 case TRANSACTION_setPhoneState:
1289//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1290// case TRANSACTION_setForceUse:
1291 case TRANSACTION_initStreamVolume:
1292 case TRANSACTION_setStreamVolumeIndex:
1293 case TRANSACTION_setVolumeIndexForAttributes:
1294 case TRANSACTION_getStreamVolumeIndex:
1295 case TRANSACTION_getVolumeIndexForAttributes:
1296 case TRANSACTION_getMinVolumeIndexForAttributes:
1297 case TRANSACTION_getMaxVolumeIndexForAttributes:
1298 case TRANSACTION_isStreamActive:
1299 case TRANSACTION_isStreamActiveRemotely:
1300 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001301 case TRANSACTION_registerPolicyMixes:
1302 case TRANSACTION_setMasterMono:
1303 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001304 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001305 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001306 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001307 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001308 case TRANSACTION_setA11yServicesUids:
1309 case TRANSACTION_setUidDeviceAffinities:
1310 case TRANSACTION_removeUidDeviceAffinities:
1311 case TRANSACTION_setUserIdDeviceAffinities:
1312 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001313 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001314 case TRANSACTION_listAudioVolumeGroups:
1315 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1316 case TRANSACTION_acquireSoundTriggerSession:
1317 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001318 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001319 case TRANSACTION_setRttEnabled:
1320 case TRANSACTION_isCallScreenModeSupported:
1321 case TRANSACTION_setDevicesRoleForStrategy:
1322 case TRANSACTION_setSupportedSystemUsages:
1323 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001324 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001325 case TRANSACTION_getDevicesForRoleAndStrategy:
1326 case TRANSACTION_getDevicesForAttributes:
1327 case TRANSACTION_setAllowedCapturePolicy:
1328 case TRANSACTION_onNewAudioModulesAvailable:
1329 case TRANSACTION_setCurrentImeUid:
1330 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1331 case TRANSACTION_setDevicesRoleForCapturePreset:
1332 case TRANSACTION_addDevicesRoleForCapturePreset:
1333 case TRANSACTION_removeDevicesRoleForCapturePreset:
1334 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001335 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001336 case TRANSACTION_getSpatializer:
1337 case TRANSACTION_setPreferredMixerAttributes:
1338 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001339 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1340 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1341 __func__, code, IPCThreadState::self()->getCallingPid(),
1342 IPCThreadState::self()->getCallingUid());
1343 return INVALID_OPERATION;
1344 }
1345 } break;
1346 default:
1347 break;
1348 }
1349
Andy Hungc747c532022-03-07 21:41:14 -08001350 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1351 mediautils::TimeCheck check(
1352 std::string("IAudioPolicyService::").append(methodName),
1353 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1354 if (timeout) {
1355 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1356 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1357 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1358 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1359 .record();
1360 } else {
1361 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1362 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001363 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1364 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1365 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001366
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001367 switch (code) {
1368 case SHELL_COMMAND_TRANSACTION: {
1369 int in = data.readFileDescriptor();
1370 int out = data.readFileDescriptor();
1371 int err = data.readFileDescriptor();
1372 int argc = data.readInt32();
1373 Vector<String16> args;
1374 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1375 args.add(data.readString16());
1376 }
1377 sp<IBinder> unusedCallback;
1378 sp<IResultReceiver> resultReceiver;
1379 status_t status;
1380 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1381 return status;
1382 }
1383 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1384 return status;
1385 }
1386 status = shellCommand(in, out, err, args);
1387 if (resultReceiver != nullptr) {
1388 resultReceiver->send(status);
1389 }
1390 return NO_ERROR;
1391 }
1392 }
1393
Mathias Agopian65ab4712010-07-14 17:59:35 -07001394 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1395}
1396
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001397// ------------------- Shell command implementation -------------------
1398
1399// NOTE: This is a remote API - make sure all args are validated
1400status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1401 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1402 return PERMISSION_DENIED;
1403 }
1404 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1405 return BAD_VALUE;
1406 }
jovanakbe066e12019-09-02 11:54:39 -07001407 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001408 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001409 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001410 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001411 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001412 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001413 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1414 purgePermissionCache();
1415 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001416 } else if (args.size() == 1 && args[0] == String16("help")) {
1417 printHelp(out);
1418 return NO_ERROR;
1419 }
1420 printHelp(err);
1421 return BAD_VALUE;
1422}
1423
jovanakbe066e12019-09-02 11:54:39 -07001424static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1425 if (userId < 0) {
1426 ALOGE("Invalid user: %d", userId);
1427 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001428 return BAD_VALUE;
1429 }
jovanakbe066e12019-09-02 11:54:39 -07001430
1431 PermissionController pc;
1432 uid = pc.getPackageUid(packageName, 0);
1433 if (uid <= 0) {
1434 ALOGE("Unknown package: '%s'", String8(packageName).string());
1435 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1436 return BAD_VALUE;
1437 }
1438
1439 uid = multiuser_get_uid(userId, uid);
1440 return NO_ERROR;
1441}
1442
1443status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1444 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1445 if (!(args.size() == 3 || args.size() == 5)) {
1446 printHelp(err);
1447 return BAD_VALUE;
1448 }
1449
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001450 bool active = false;
1451 if (args[2] == String16("active")) {
1452 active = true;
1453 } else if ((args[2] != String16("idle"))) {
1454 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1455 return BAD_VALUE;
1456 }
jovanakbe066e12019-09-02 11:54:39 -07001457
1458 int userId = 0;
1459 if (args.size() >= 5 && args[3] == String16("--user")) {
1460 userId = atoi(String8(args[4]));
1461 }
1462
1463 uid_t uid;
1464 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1465 return BAD_VALUE;
1466 }
1467
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001468 sp<UidPolicy> uidPolicy;
1469 {
1470 Mutex::Autolock _l(mLock);
1471 uidPolicy = mUidPolicy;
1472 }
1473 if (uidPolicy) {
1474 uidPolicy->addOverrideUid(uid, active);
1475 return NO_ERROR;
1476 }
1477 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001478}
1479
1480status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001481 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1482 if (!(args.size() == 2 || args.size() == 4)) {
1483 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001484 return BAD_VALUE;
1485 }
jovanakbe066e12019-09-02 11:54:39 -07001486
1487 int userId = 0;
1488 if (args.size() >= 4 && args[2] == String16("--user")) {
1489 userId = atoi(String8(args[3]));
1490 }
1491
1492 uid_t uid;
1493 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1494 return BAD_VALUE;
1495 }
1496
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001497 sp<UidPolicy> uidPolicy;
1498 {
1499 Mutex::Autolock _l(mLock);
1500 uidPolicy = mUidPolicy;
1501 }
1502 if (uidPolicy) {
1503 uidPolicy->removeOverrideUid(uid);
1504 return NO_ERROR;
1505 }
1506 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001507}
1508
1509status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001510 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1511 if (!(args.size() == 2 || args.size() == 4)) {
1512 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001513 return BAD_VALUE;
1514 }
jovanakbe066e12019-09-02 11:54:39 -07001515
1516 int userId = 0;
1517 if (args.size() >= 4 && args[2] == String16("--user")) {
1518 userId = atoi(String8(args[3]));
1519 }
1520
1521 uid_t uid;
1522 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1523 return BAD_VALUE;
1524 }
1525
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001526 sp<UidPolicy> uidPolicy;
1527 {
1528 Mutex::Autolock _l(mLock);
1529 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001530 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001531 if (uidPolicy) {
1532 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1533 }
1534 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001535}
1536
1537status_t AudioPolicyService::printHelp(int out) {
1538 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001539 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1540 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1541 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001542 " help print this message\n");
1543}
1544
Eric Laurent0d13fea2022-11-04 17:12:08 +01001545status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1546 const audio_config_base_t& config,
1547 const audio_output_flags_t flags) {
1548 return mUsecaseValidator->registerStream(output, config, flags);
1549}
1550
1551status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1552 return mUsecaseValidator->unregisterStream(output);
1553}
1554
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001555// ----------- AudioPolicyService::UidPolicy implementation ----------
1556
1557void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001558 status_t res = mAm.linkToDeath(this);
1559 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001560 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001561 | ActivityManager::UID_OBSERVER_ACTIVE
1562 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001563 ActivityManager::PROCESS_STATE_UNKNOWN,
1564 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001565 if (!res) {
1566 Mutex::Autolock _l(mLock);
1567 mObserverRegistered = true;
1568 } else {
1569 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001570
Steven Moreland2f348142019-07-02 15:59:07 -07001571 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001572 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001573}
1574
1575void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001576 mAm.unlinkToDeath(this);
1577 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001578 Mutex::Autolock _l(mLock);
1579 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001580}
1581
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001582void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1583 Mutex::Autolock _l(mLock);
1584 mCachedUids.clear();
1585 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001586}
1587
Eric Laurente8c8b432018-10-17 10:08:02 -07001588void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001589 bool needToReregister = false;
1590 {
1591 Mutex::Autolock _l(mLock);
1592 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001593 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001594 if (needToReregister) {
1595 // Looks like ActivityManager has died previously, attempt to re-register.
1596 registerSelf();
1597 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001598}
1599
1600bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1601 if (isServiceUid(uid)) return true;
1602 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001603 {
1604 Mutex::Autolock _l(mLock);
1605 auto overrideIter = mOverrideUids.find(uid);
1606 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001607 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001608 }
1609 // In an absense of the ActivityManager, assume everything to be active.
1610 if (!mObserverRegistered) return true;
1611 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001612 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001613 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001614 }
1615 }
1616 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001617 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001618 {
1619 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001620 mCachedUids.insert(std::pair<uid_t,
1621 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1622 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001623 }
1624 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001625}
1626
Eric Laurente8c8b432018-10-17 10:08:02 -07001627int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1628 if (isServiceUid(uid)) {
1629 return ActivityManager::PROCESS_STATE_TOP;
1630 }
1631 checkRegistered();
1632 {
1633 Mutex::Autolock _l(mLock);
1634 auto overrideIter = mOverrideUids.find(uid);
1635 if (overrideIter != mOverrideUids.end()) {
1636 if (overrideIter->second.first) {
1637 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1638 return overrideIter->second.second;
1639 } else {
1640 auto cacheIter = mCachedUids.find(uid);
1641 if (cacheIter != mCachedUids.end()) {
1642 return cacheIter->second.second;
1643 }
1644 }
1645 }
1646 return ActivityManager::PROCESS_STATE_UNKNOWN;
1647 }
1648 // In an absense of the ActivityManager, assume everything to be active.
1649 if (!mObserverRegistered) {
1650 return ActivityManager::PROCESS_STATE_TOP;
1651 }
1652 auto cacheIter = mCachedUids.find(uid);
1653 if (cacheIter != mCachedUids.end()) {
1654 if (cacheIter->second.first) {
1655 return cacheIter->second.second;
1656 } else {
1657 return ActivityManager::PROCESS_STATE_UNKNOWN;
1658 }
1659 }
1660 }
1661 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001662 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001663 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1664 if (active) {
1665 state = am.getUidProcessState(uid, String16("audioserver"));
1666 }
1667 {
1668 Mutex::Autolock _l(mLock);
1669 mCachedUids.insert(std::pair<uid_t,
1670 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1671 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001672
Eric Laurente8c8b432018-10-17 10:08:02 -07001673 return state;
1674}
1675
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001676void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001677 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001678}
1679
1680void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001681 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001682}
1683
1684void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001685 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001686}
1687
Eric Laurente8c8b432018-10-17 10:08:02 -07001688void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1689 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001690 int64_t procStateSeq __unused,
1691 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001692 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1693 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001694 }
1695}
1696
Austin Borgerdddb7552023-03-30 17:53:01 -07001697void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001698}
1699
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001700void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001701 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1702}
1703
1704void AudioPolicyService::UidPolicy::notifyService() {
1705 sp<AudioPolicyService> service = mService.promote();
1706 if (service != nullptr) {
1707 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001708 }
1709}
1710
Eric Laurente8c8b432018-10-17 10:08:02 -07001711void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1712 std::pair<bool, int>> *uids,
1713 uid_t uid,
1714 bool active,
1715 int state,
1716 bool insert) {
1717 if (isServiceUid(uid)) {
1718 return;
1719 }
1720 bool wasActive = isUidActive(uid);
1721 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001722 {
1723 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001724 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001725 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001726 if (wasActive != isUidActive(uid) || state != previousState) {
1727 notifyService();
1728 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001729}
1730
Eric Laurente8c8b432018-10-17 10:08:02 -07001731void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1732 std::pair<bool, int>> *uids,
1733 uid_t uid,
1734 bool active,
1735 int state,
1736 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001737 auto it = uids->find(uid);
1738 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001739 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001740 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1741 it->second.first = active;
1742 }
1743 if (it->second.first) {
1744 it->second.second = state;
1745 } else {
1746 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1747 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001748 } else {
1749 uids->erase(it);
1750 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001751 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1752 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1753 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001754 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001755}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001756
Eric Laurent4eb58f12018-12-07 16:41:02 -08001757bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001758 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001759 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001760 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001761 continue;
1762 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001763 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1764 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001765 return true;
1766 }
1767 }
1768 return false;
1769}
1770
Eric Laurentb78763e2018-10-17 10:08:02 -07001771bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1772{
1773 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1774 return it != mA11yUids.end();
1775}
1776
Oscar Azucena829d90d2022-01-28 17:17:56 -08001777void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1778 mAssistantUids.clear();
1779 mAssistantUids = uids;
1780}
1781
1782bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1783{
1784 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1785 return it != mAssistantUids.end();
1786}
1787
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001788void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1789 mActiveAssistantUids = activeUids;
1790}
1791
1792bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1793{
1794 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1795 mActiveAssistantUids.end(), uid);
1796 return it != mActiveAssistantUids.end();
1797}
1798
Oscar Azucena829d90d2022-01-28 17:17:56 -08001799void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1800 const size_t SIZE = 256;
1801 char buffer[SIZE];
1802 String8 result;
1803 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1804 snprintf(buffer, SIZE, "\t%s: \n", title);
1805 result.append(buffer);
1806 int counter = 0;
1807 if (uids.empty()) {
1808 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1809 result.append(buffer);
1810 return;
1811 }
1812 for (const auto &uid : uids) {
1813 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1814 result.append(buffer);
1815 }
1816 };
1817
1818 snprintf(buffer, SIZE, "UID Policy:\n");
1819 result.append(buffer);
1820 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1821 result.append(buffer);
1822
1823 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001824 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001825
1826 appendUidsToResult("Accessibility UIDs", mA11yUids);
1827
1828 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1829 result.append(buffer);
1830
1831 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1832 result.append(buffer);
1833
1834 write(fd, result.string(), result.size());
1835}
1836
Michael Groovercfd28302018-12-11 19:16:46 -08001837// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1838void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1839 SensorPrivacyManager spm;
1840 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
Eric Laurent35cd7932022-11-17 11:47:19 +01001841 (void)spm.addToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001842 spm.addSensorPrivacyListener(this);
1843}
1844
1845void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1846 SensorPrivacyManager spm;
1847 spm.removeSensorPrivacyListener(this);
Eric Laurent35cd7932022-11-17 11:47:19 +01001848 spm.removeToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001849}
1850
1851bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1852 return mSensorPrivacyEnabled;
1853}
1854
Evan Seversond8dc6832022-01-27 10:47:03 -08001855binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1856 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001857 mSensorPrivacyEnabled = enabled;
1858 sp<AudioPolicyService> service = mService.promote();
1859 if (service != nullptr) {
1860 service->updateUidStates();
1861 }
1862 return binder::Status::ok();
1863}
1864
Eric Laurented726cc2021-07-01 14:26:41 +02001865// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1866
1867// static
1868sp<AudioPolicyService::OpRecordAudioMonitor>
1869AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1870 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1871 wp<AudioCommandThread> commandThread)
1872{
Eric Laurent987ce102021-07-05 12:11:51 +02001873 if (isAudioServerOrRootUid(attributionSource.uid)) {
1874 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001875 attributionSource.toString().c_str());
1876 return nullptr;
1877 }
1878
1879 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1880 ALOGD("not monitoring app op for uid %d and source %d",
1881 attributionSource.uid, attr.source);
1882 return nullptr;
1883 }
1884
1885 if (!attributionSource.packageName.has_value()
1886 || attributionSource.packageName.value().size() == 0) {
1887 return nullptr;
1888 }
1889 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1890}
1891
1892AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1893 const AttributionSourceState& attributionSource, int32_t appOp,
1894 wp<AudioCommandThread> commandThread) :
1895 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1896 mCommandThread(commandThread)
1897{
1898}
1899
1900AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1901{
1902 if (mOpCallback != 0) {
1903 mAppOpsManager.stopWatchingMode(mOpCallback);
1904 }
1905 mOpCallback.clear();
1906}
1907
1908void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1909{
1910 checkOp();
1911 mOpCallback = new RecordAudioOpCallback(this);
1912 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1913 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1914 // since it controls the mic permission for legacy apps.
1915 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1916 mAttributionSource.packageName.value_or(""))),
1917 mOpCallback);
1918}
1919
1920bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1921 return mHasOp.load();
1922}
1923
1924// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1925// is updated in AppOp callback and in onFirstRef()
1926// Note this method is never called (and never to be) for audio server / root track
1927// due to the UID in createIfNeeded(). As a result for those record track, it's:
1928// - not called from constructor,
1929// - not called from RecordAudioOpCallback because the callback is not installed in this case
1930void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1931{
1932 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1933 // since it controls the mic permission for legacy apps.
1934 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1935 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1936 mAttributionSource.packageName.value_or(""))));
1937 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1938 // verbose logging only log when appOp changed
1939 ALOGI_IF(hasIt != mHasOp.load(),
1940 "App op %d missing, %ssilencing record %s",
1941 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1942 mHasOp.store(hasIt);
1943
1944 if (updateUidStates) {
1945 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1946 if (commandThread != nullptr) {
1947 commandThread->updateUidStatesCommand();
1948 }
1949 }
1950}
1951
1952AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1953 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1954{ }
1955
1956void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1957 const String16& packageName __unused) {
1958 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1959 if (monitor != NULL) {
1960 if (op != monitor->getOp()) {
1961 return;
1962 }
1963 monitor->checkOp(true);
1964 }
1965}
1966
1967
Mathias Agopian65ab4712010-07-14 17:59:35 -07001968// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1969
Eric Laurentbfb1b832013-01-07 09:53:42 -08001970AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1971 const wp<AudioPolicyService>& service)
1972 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001973{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001974}
1975
1976
1977AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1978{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001979 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001980 release_wake_lock(mName.string());
1981 }
1982 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001983}
1984
1985void AudioPolicyService::AudioCommandThread::onFirstRef()
1986{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001987 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001988}
1989
1990bool AudioPolicyService::AudioCommandThread::threadLoop()
1991{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001992 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001993
1994 mLock.lock();
1995 while (!exitPending())
1996 {
Eric Laurent59a89232014-06-08 14:14:17 -07001997 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001998 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001999 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002000 nsecs_t curTime = systemTime();
2001 // commands are sorted by increasing time stamp: execute them from index 0 and up
2002 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002003 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002004 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002005 if (mAudioCommands.isEmpty()) {
2006 ++numTimesBecameEmpty;
2007 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002008 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002009
2010 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002011 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002012 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002013 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07002014 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002015 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07002016 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
2017 data->mVolume,
2018 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002019 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002020 }break;
2021 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002022 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002023 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2024 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002025 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002026 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002027 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002028 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002029 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002030 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002031 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002032 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002033 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002034 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002035 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002036 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002037 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002038 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002039 ALOGV("AudioCommandThread() processing stop output portId %d",
2040 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002041 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002042 if (svc == 0) {
2043 break;
2044 }
2045 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002046 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002047 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002048 }break;
2049 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002050 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002051 ALOGV("AudioCommandThread() processing release output portId %d",
2052 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002053 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002054 if (svc == 0) {
2055 break;
2056 }
2057 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002058 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002059 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002060 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002061 case CREATE_AUDIO_PATCH: {
2062 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2063 ALOGV("AudioCommandThread() processing create audio patch");
2064 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2065 if (af == 0) {
2066 command->mStatus = PERMISSION_DENIED;
2067 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002068 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002069 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002070 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002071 }
2072 } break;
2073 case RELEASE_AUDIO_PATCH: {
2074 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2075 ALOGV("AudioCommandThread() processing release audio patch");
2076 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2077 if (af == 0) {
2078 command->mStatus = PERMISSION_DENIED;
2079 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002080 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002081 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002082 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002083 }
2084 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002085 case UPDATE_AUDIOPORT_LIST: {
2086 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002087 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002088 if (svc == 0) {
2089 break;
2090 }
2091 mLock.unlock();
2092 svc->doOnAudioPortListUpdate();
2093 mLock.lock();
2094 }break;
2095 case UPDATE_AUDIOPATCH_LIST: {
2096 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002097 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002098 if (svc == 0) {
2099 break;
2100 }
2101 mLock.unlock();
2102 svc->doOnAudioPatchListUpdate();
2103 mLock.lock();
2104 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002105 case CHANGED_AUDIOVOLUMEGROUP: {
2106 AudioVolumeGroupData *data =
2107 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2108 ALOGV("AudioCommandThread() processing update audio volume group");
2109 svc = mService.promote();
2110 if (svc == 0) {
2111 break;
2112 }
2113 mLock.unlock();
2114 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2115 mLock.lock();
2116 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002117 case SET_AUDIOPORT_CONFIG: {
2118 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2119 ALOGV("AudioCommandThread() processing set port config");
2120 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2121 if (af == 0) {
2122 command->mStatus = PERMISSION_DENIED;
2123 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002124 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002125 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002126 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002127 }
2128 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002129 case DYN_POLICY_MIX_STATE_UPDATE: {
2130 DynPolicyMixStateUpdateData *data =
2131 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002132 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2133 data->mRegId.string(), data->mState);
2134 svc = mService.promote();
2135 if (svc == 0) {
2136 break;
2137 }
2138 mLock.unlock();
2139 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2140 mLock.lock();
2141 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002142 case RECORDING_CONFIGURATION_UPDATE: {
2143 RecordingConfigurationUpdateData *data =
2144 (RecordingConfigurationUpdateData *)command->mParam.get();
2145 ALOGV("AudioCommandThread() processing recording configuration update");
2146 svc = mService.promote();
2147 if (svc == 0) {
2148 break;
2149 }
2150 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002151 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002152 &data->mClientConfig, data->mClientEffects,
2153 &data->mDeviceConfig, data->mEffects,
2154 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002155 mLock.lock();
2156 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002157 case SET_EFFECT_SUSPENDED: {
2158 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2159 ALOGV("AudioCommandThread() processing set effect suspended");
2160 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2161 if (af != 0) {
2162 mLock.unlock();
2163 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2164 mLock.lock();
2165 }
2166 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002167 case AUDIO_MODULES_UPDATE: {
2168 ALOGV("AudioCommandThread() processing audio modules update");
2169 svc = mService.promote();
2170 if (svc == 0) {
2171 break;
2172 }
2173 mLock.unlock();
2174 svc->doOnNewAudioModulesAvailable();
2175 mLock.lock();
2176 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002177 case ROUTING_UPDATED: {
2178 ALOGV("AudioCommandThread() processing routing update");
2179 svc = mService.promote();
2180 if (svc == 0) {
2181 break;
2182 }
2183 mLock.unlock();
2184 svc->doOnRoutingUpdated();
2185 mLock.lock();
2186 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002187
Eric Laurented726cc2021-07-01 14:26:41 +02002188 case UPDATE_UID_STATES: {
2189 ALOGV("AudioCommandThread() processing updateUID states");
2190 svc = mService.promote();
2191 if (svc == 0) {
2192 break;
2193 }
2194 mLock.unlock();
2195 svc->updateUidStates();
2196 mLock.lock();
2197 } break;
2198
Eric Laurent15903592022-02-24 20:44:36 +01002199 case CHECK_SPATIALIZER_OUTPUT: {
2200 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002201 svc = mService.promote();
2202 if (svc == 0) {
2203 break;
2204 }
2205 mLock.unlock();
2206 svc->doOnCheckSpatializer();
2207 mLock.lock();
2208 } break;
2209
Eric Laurent15903592022-02-24 20:44:36 +01002210 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2211 ALOGV("AudioCommandThread() processing update spatializer tracks");
2212 svc = mService.promote();
2213 if (svc == 0) {
2214 break;
2215 }
2216 mLock.unlock();
2217 svc->doOnUpdateActiveSpatializerTracks();
2218 mLock.lock();
2219 } break;
2220
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002221 case VOL_RANGE_INIT_REQUEST: {
2222 ALOGV("AudioCommandThread() processing volume range init request");
2223 svc = mService.promote();
2224 if (svc == 0) {
2225 break;
2226 }
2227 mLock.unlock();
2228 svc->doOnVolumeRangeInitRequest();
2229 mLock.lock();
2230 } break;
2231
Mathias Agopian65ab4712010-07-14 17:59:35 -07002232 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002233 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002234 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002235 {
2236 Mutex::Autolock _l(command->mLock);
2237 if (command->mWaitStatus) {
2238 command->mWaitStatus = false;
2239 command->mCond.signal();
2240 }
2241 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002242 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002243 // release mLock before releasing strong reference on the service as
2244 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2245 // acquires mLock.
2246 mLock.unlock();
2247 svc.clear();
2248 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002249 } else {
2250 waitTime = mAudioCommands[0]->mTime - curTime;
2251 break;
2252 }
2253 }
Zach Janga754b4f2015-10-27 01:29:34 +00002254
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002255 // release delayed commands wake lock as many times as we made the queue is
2256 // empty during popping.
2257 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002258 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002259 }
2260
2261 // At this stage we have either an empty command queue or the first command in the queue
2262 // has a finite delay. So unless we are exiting it is safe to wait.
2263 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002264 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002265 if (waitTime == -1) {
2266 mWaitWorkCV.wait(mLock);
2267 } else {
2268 mWaitWorkCV.waitRelative(mLock, waitTime);
2269 }
Eric Laurent59a89232014-06-08 14:14:17 -07002270 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002271 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002272 // release delayed commands wake lock before quitting
2273 if (!mAudioCommands.isEmpty()) {
2274 release_wake_lock(mName.string());
2275 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002276 mLock.unlock();
2277 return false;
2278}
2279
2280status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2281{
2282 const size_t SIZE = 256;
2283 char buffer[SIZE];
2284 String8 result;
2285
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002286 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002287 if (!locked) {
2288 String8 result2(kCmdDeadlockedString);
2289 write(fd, result2.string(), result2.size());
2290 }
2291
2292 snprintf(buffer, SIZE, "- Commands:\n");
2293 result = String8(buffer);
2294 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002295 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002296 mAudioCommands[i]->dump(buffer, SIZE);
2297 result.append(buffer);
2298 }
2299 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002300 if (mLastCommand != 0) {
2301 mLastCommand->dump(buffer, SIZE);
2302 result.append(buffer);
2303 } else {
2304 result.append(" none\n");
2305 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002306
2307 write(fd, result.string(), result.size());
2308
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002309 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002310
2311 return NO_ERROR;
2312}
2313
Glenn Kastenfff6d712012-01-12 16:38:12 -08002314status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002315 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002316 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002317 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002318{
Eric Laurent0ede8922014-05-09 18:04:42 -07002319 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002320 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002321 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002322 data->mStream = stream;
2323 data->mVolume = volume;
2324 data->mIO = output;
2325 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002326 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002327 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002328 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002329 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002330}
2331
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002332status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002333 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002334 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002335{
Eric Laurent0ede8922014-05-09 18:04:42 -07002336 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002337 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002338 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002339 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002340 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002341 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 parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002344 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002345 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002346}
2347
2348status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2349{
Eric Laurent0ede8922014-05-09 18:04:42 -07002350 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002351 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002352 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002353 data->mVolume = volume;
2354 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002355 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002356 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002357 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002358}
2359
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002360void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2361 audio_session_t sessionId,
2362 bool suspended)
2363{
2364 sp<AudioCommand> command = new AudioCommand();
2365 command->mCommand = SET_EFFECT_SUSPENDED;
2366 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2367 data->mEffectId = effectId;
2368 data->mSessionId = sessionId;
2369 data->mSuspended = suspended;
2370 command->mParam = data;
2371 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2372 effectId, sessionId, suspended);
2373 sendCommand(command);
2374}
2375
2376
Eric Laurentd7fe0862018-07-14 16:48:01 -07002377void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002378{
Eric Laurent0ede8922014-05-09 18:04:42 -07002379 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002380 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002381 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002382 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002383 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002384 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002385 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002386}
2387
Eric Laurentd7fe0862018-07-14 16:48:01 -07002388void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002389{
Eric Laurent0ede8922014-05-09 18:04:42 -07002390 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002391 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002392 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002393 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002394 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002395 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002396 sendCommand(command);
2397}
2398
Eric Laurent951f4552014-05-20 10:48:17 -07002399status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2400 const struct audio_patch *patch,
2401 audio_patch_handle_t *handle,
2402 int delayMs)
2403{
2404 status_t status = NO_ERROR;
2405
2406 sp<AudioCommand> command = new AudioCommand();
2407 command->mCommand = CREATE_AUDIO_PATCH;
2408 CreateAudioPatchData *data = new CreateAudioPatchData();
2409 data->mPatch = *patch;
2410 data->mHandle = *handle;
2411 command->mParam = data;
2412 command->mWaitStatus = true;
2413 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2414 status = sendCommand(command, delayMs);
2415 if (status == NO_ERROR) {
2416 *handle = data->mHandle;
2417 }
2418 return status;
2419}
2420
2421status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2422 int delayMs)
2423{
2424 sp<AudioCommand> command = new AudioCommand();
2425 command->mCommand = RELEASE_AUDIO_PATCH;
2426 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2427 data->mHandle = handle;
2428 command->mParam = data;
2429 command->mWaitStatus = true;
2430 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2431 return sendCommand(command, delayMs);
2432}
2433
Eric Laurentb52c1522014-05-20 11:27:36 -07002434void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2435{
2436 sp<AudioCommand> command = new AudioCommand();
2437 command->mCommand = UPDATE_AUDIOPORT_LIST;
2438 ALOGV("AudioCommandThread() adding update audio port list");
2439 sendCommand(command);
2440}
2441
Eric Laurented726cc2021-07-01 14:26:41 +02002442void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2443{
2444 sp<AudioCommand> command = new AudioCommand();
2445 command->mCommand = UPDATE_UID_STATES;
2446 ALOGV("AudioCommandThread() adding update UID states");
2447 sendCommand(command);
2448}
2449
Eric Laurentb52c1522014-05-20 11:27:36 -07002450void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2451{
2452 sp<AudioCommand>command = new AudioCommand();
2453 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2454 ALOGV("AudioCommandThread() adding update audio patch list");
2455 sendCommand(command);
2456}
2457
François Gaffiecfe17322018-11-07 13:41:29 +01002458void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2459 int flags)
2460{
2461 sp<AudioCommand>command = new AudioCommand();
2462 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2463 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2464 data->mGroup = group;
2465 data->mFlags = flags;
2466 command->mParam = data;
2467 ALOGV("AudioCommandThread() adding audio volume group changed");
2468 sendCommand(command);
2469}
2470
Eric Laurente1715a42014-05-20 11:30:42 -07002471status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2472 const struct audio_port_config *config, int delayMs)
2473{
2474 sp<AudioCommand> command = new AudioCommand();
2475 command->mCommand = SET_AUDIOPORT_CONFIG;
2476 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2477 data->mConfig = *config;
2478 command->mParam = data;
2479 command->mWaitStatus = true;
2480 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2481 return sendCommand(command, delayMs);
2482}
2483
Jean-Michel Trivide801052015-04-14 19:10:14 -07002484void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002485 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002486{
2487 sp<AudioCommand> command = new AudioCommand();
2488 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2489 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2490 data->mRegId = regId;
2491 data->mState = state;
2492 command->mParam = data;
2493 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2494 regId.string(), state);
2495 sendCommand(command);
2496}
2497
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002498void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002499 int event,
2500 const record_client_info_t *clientInfo,
2501 const audio_config_base_t *clientConfig,
2502 std::vector<effect_descriptor_t> clientEffects,
2503 const audio_config_base_t *deviceConfig,
2504 std::vector<effect_descriptor_t> effects,
2505 audio_patch_handle_t patchHandle,
2506 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002507{
2508 sp<AudioCommand>command = new AudioCommand();
2509 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2510 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2511 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002512 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002513 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002514 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002515 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002516 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002517 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002518 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002519 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002520 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2521 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002522 sendCommand(command);
2523}
2524
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002525void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2526{
2527 sp<AudioCommand> command = new AudioCommand();
2528 command->mCommand = AUDIO_MODULES_UPDATE;
2529 sendCommand(command);
2530}
2531
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002532void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2533{
2534 sp<AudioCommand>command = new AudioCommand();
2535 command->mCommand = ROUTING_UPDATED;
2536 ALOGV("AudioCommandThread() adding routing update");
2537 sendCommand(command);
2538}
2539
Eric Laurent81dd0f52021-07-05 11:54:40 +02002540void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2541{
2542 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002543 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002544 ALOGV("AudioCommandThread() adding check spatializer");
2545 sendCommand(command);
2546}
2547
Eric Laurent15903592022-02-24 20:44:36 +01002548void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2549{
2550 sp<AudioCommand>command = new AudioCommand();
2551 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2552 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2553 sendCommand(command);
2554}
2555
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002556void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2557{
2558 sp<AudioCommand>command = new AudioCommand();
2559 command->mCommand = VOL_RANGE_INIT_REQUEST;
2560 ALOGV("AudioCommandThread() adding volume range init request");
2561 sendCommand(command);
2562}
2563
Eric Laurent0ede8922014-05-09 18:04:42 -07002564status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2565{
2566 {
2567 Mutex::Autolock _l(mLock);
2568 insertCommand_l(command, delayMs);
2569 mWaitWorkCV.signal();
2570 }
2571 Mutex::Autolock _l(command->mLock);
2572 while (command->mWaitStatus) {
2573 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2574 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2575 command->mStatus = TIMED_OUT;
2576 command->mWaitStatus = false;
2577 }
2578 }
2579 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002580}
2581
Mathias Agopian65ab4712010-07-14 17:59:35 -07002582// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002583void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002584{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002585 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002586 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002587 command->mTime = systemTime() + milliseconds(delayMs);
2588
2589 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002590 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002591 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2592 }
2593
2594 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002595 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002596 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002597 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2598 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002599
2600 // create audio patch or release audio patch commands are equivalent
2601 // with regard to filtering
2602 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2603 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2604 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2605 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2606 continue;
2607 }
2608 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002609
2610 switch (command->mCommand) {
2611 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002612 ParametersData *data = (ParametersData *)command->mParam.get();
2613 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002614 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002615 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002616 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002617 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2618 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2619 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002620 String8 key;
2621 String8 value;
2622 param.getAt(j, key, value);
2623 for (size_t k = 0; k < param2.size(); k++) {
2624 String8 key2;
2625 String8 value2;
2626 param2.getAt(k, key2, value2);
2627 if (key2 == key) {
2628 param2.remove(key2);
2629 ALOGV("Filtering out parameter %s", key2.string());
2630 break;
2631 }
2632 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002633 }
2634 // if all keys have been filtered out, remove the command.
2635 // otherwise, update the key value pairs
2636 if (param2.size() == 0) {
2637 removedCommands.add(command2);
2638 } else {
2639 data2->mKeyValuePairs = param2.toString();
2640 }
Eric Laurent21e54562013-09-23 12:08:05 -07002641 command->mTime = command2->mTime;
2642 // force delayMs to non 0 so that code below does not request to wait for
2643 // command status as the command is now delayed
2644 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002645 } break;
2646
2647 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002648 VolumeData *data = (VolumeData *)command->mParam.get();
2649 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002650 if (data->mIO != data2->mIO) break;
2651 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002652 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002653 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002654 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002655 command->mTime = command2->mTime;
2656 // force delayMs to non 0 so that code below does not request to wait for
2657 // command status as the command is now delayed
2658 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002659 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002660
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002661 case SET_VOICE_VOLUME: {
2662 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2663 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2664 ALOGV("Filtering out voice volume command value %f replaced by %f",
2665 data2->mVolume, data->mVolume);
2666 removedCommands.add(command2);
2667 command->mTime = command2->mTime;
2668 // force delayMs to non 0 so that code below does not request to wait for
2669 // command status as the command is now delayed
2670 delayMs = 1;
2671 } break;
2672
Eric Laurente45b48a2014-09-04 16:40:57 -07002673 case CREATE_AUDIO_PATCH:
2674 case RELEASE_AUDIO_PATCH: {
2675 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002676 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002677 if (command->mCommand == CREATE_AUDIO_PATCH) {
2678 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002679 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002680 } else {
2681 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002682 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002683 }
2684 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002685 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002686 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2687 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002688 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002689 } else {
2690 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002691 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002692 }
2693 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002694 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2695 same output. */
2696 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2697 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2698 bool isOutputDiff = false;
2699 if (patch.num_sources == patch2.num_sources) {
2700 for (unsigned count = 0; count < patch.num_sources; count++) {
2701 if (patch.sources[count].id != patch2.sources[count].id) {
2702 isOutputDiff = true;
2703 break;
2704 }
2705 }
2706 if (isOutputDiff)
2707 break;
2708 }
2709 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002710 ALOGV("Filtering out %s audio patch command for handle %d",
2711 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2712 removedCommands.add(command2);
2713 command->mTime = command2->mTime;
2714 // force delayMs to non 0 so that code below does not request to wait for
2715 // command status as the command is now delayed
2716 delayMs = 1;
2717 } break;
2718
Jean-Michel Trivide801052015-04-14 19:10:14 -07002719 case DYN_POLICY_MIX_STATE_UPDATE: {
2720
2721 } break;
2722
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002723 case RECORDING_CONFIGURATION_UPDATE: {
2724
2725 } break;
2726
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002727 case ROUTING_UPDATED: {
2728
2729 } break;
2730
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002731 case VOL_RANGE_INIT_REQUEST: {
2732 // command may come from different requests, do not filter
2733 } break;
2734
Mathias Agopian65ab4712010-07-14 17:59:35 -07002735 default:
2736 break;
2737 }
2738 }
2739
2740 // remove filtered commands
2741 for (size_t j = 0; j < removedCommands.size(); j++) {
2742 // removed commands always have time stamps greater than current command
2743 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002744 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002745 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002746 mAudioCommands.removeAt(k);
2747 break;
2748 }
2749 }
2750 }
2751 removedCommands.clear();
2752
Eric Laurentaa79bef2015-01-15 14:33:51 -08002753 // Disable wait for status if delay is not 0.
2754 // Except for create audio patch command because the returned patch handle
2755 // is needed by audio policy manager
2756 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002757 command->mWaitStatus = false;
2758 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002759
Mathias Agopian65ab4712010-07-14 17:59:35 -07002760 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002761 ALOGV("inserting command: %d at index %zd, num commands %zu",
2762 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002763 mAudioCommands.insertAt(command, i + 1);
2764}
2765
2766void AudioPolicyService::AudioCommandThread::exit()
2767{
Steve Block3856b092011-10-20 11:56:00 +01002768 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002769 {
2770 AutoMutex _l(mLock);
2771 requestExit();
2772 mWaitWorkCV.signal();
2773 }
Zach Janga754b4f2015-10-27 01:29:34 +00002774 // Note that we can call it from the thread loop if all other references have been released
2775 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002776 requestExitAndWait();
2777}
2778
2779void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2780{
2781 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2782 mCommand,
2783 (int)ns2s(mTime),
2784 (int)ns2ms(mTime)%1000,
2785 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002786 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002787}
2788
Dima Zavinfce7a472011-04-19 22:30:36 -07002789/******* helpers for the service_ops callbacks defined below *********/
2790void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2791 const char *keyValuePairs,
2792 int delayMs)
2793{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002794 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002795 delayMs);
2796}
2797
2798int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2799 float volume,
2800 audio_io_handle_t output,
2801 int delayMs)
2802{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002803 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002804 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002805}
2806
Dima Zavinfce7a472011-04-19 22:30:36 -07002807int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2808{
2809 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2810}
2811
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002812void AudioPolicyService::setEffectSuspended(int effectId,
2813 audio_session_t sessionId,
2814 bool suspended)
2815{
2816 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2817}
2818
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002819Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002820{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002821 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002822 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002823}
2824
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002825
Dima Zavinfce7a472011-04-19 22:30:36 -07002826extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002827audio_module_handle_t aps_load_hw_module(void *service __unused,
2828 const char *name);
2829audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002830 audio_devices_t *pDevices,
2831 uint32_t *pSamplingRate,
2832 audio_format_t *pFormat,
2833 audio_channel_mask_t *pChannelMask,
2834 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002835 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002836
Eric Laurent2d388ec2014-03-07 13:25:54 -08002837audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002838 audio_module_handle_t module,
2839 audio_devices_t *pDevices,
2840 uint32_t *pSamplingRate,
2841 audio_format_t *pFormat,
2842 audio_channel_mask_t *pChannelMask,
2843 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002844 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002845 const audio_offload_info_t *offloadInfo);
2846audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002847 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002848 audio_io_handle_t output2);
2849int aps_close_output(void *service __unused, audio_io_handle_t output);
2850int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2851int aps_restore_output(void *service __unused, audio_io_handle_t output);
2852audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002853 audio_devices_t *pDevices,
2854 uint32_t *pSamplingRate,
2855 audio_format_t *pFormat,
2856 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002857 audio_in_acoustics_t acoustics __unused);
2858audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002859 audio_module_handle_t module,
2860 audio_devices_t *pDevices,
2861 uint32_t *pSamplingRate,
2862 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002863 audio_channel_mask_t *pChannelMask);
2864int aps_close_input(void *service __unused, audio_io_handle_t input);
2865int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002866int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002867 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002868 audio_io_handle_t dst_output);
2869char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2870 const char *keys);
2871void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2872 const char *kv_pairs, int delay_ms);
2873int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002874 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002875 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002876int aps_set_voice_volume(void *service, float volume, int delay_ms);
2877};
Dima Zavinfce7a472011-04-19 22:30:36 -07002878
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002879} // namespace android