blob: 0c1299128ba5c3bc57c4126d44751fffc0476461 [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) \
140BINDER_METHOD_ENTRY(listAudioProductStrategies) \
141BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
142BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
143BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
144BINDER_METHOD_ENTRY(setRttEnabled) \
145BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
146BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
147BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
148BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
149BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
150BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
151BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
152BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
154BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
155BINDER_METHOD_ENTRY(getSpatializer) \
156BINDER_METHOD_ENTRY(canBeSpatialized) \
157BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
158BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
159
160// singleton for Binder Method Statistics for IAudioPolicyService
161static auto& getIAudioPolicyServiceStatistics() {
162 using Code = int;
163
164#pragma push_macro("BINDER_METHOD_ENTRY")
165#undef BINDER_METHOD_ENTRY
166#define BINDER_METHOD_ENTRY(ENTRY) \
167 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
168
169 static mediautils::MethodStatistics<Code> methodStatistics{
170 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
171 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
172 };
173#pragma pop_macro("BINDER_METHOD_ENTRY")
174
175 return methodStatistics;
176}
177
Mathias Agopian65ab4712010-07-14 17:59:35 -0700178// ----------------------------------------------------------------------------
179
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530180static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
181{
182 AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);
183 status_t status = apm->initialize();
184 if (status != NO_ERROR) {
185 delete apm;
186 apm = nullptr;
187 }
188 return apm;
189}
190
191static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
192{
193 delete interface;
194}
195// ----------------------------------------------------------------------------
196
Mathias Agopian65ab4712010-07-14 17:59:35 -0700197AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700198 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700199 mAudioPolicyManager(NULL),
200 mAudioPolicyClient(NULL),
201 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530202 mCaptureStateNotifier(false),
203 mCreateAudioPolicyManager(createAudioPolicyManager),
204 mDestroyAudioPolicyManager(destroyAudioPolicyManager) {
205}
206
207void AudioPolicyService::loadAudioPolicyManager()
208{
209 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
210 if (mLibraryHandle != nullptr) {
211 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
212 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
213 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
214 const char *lastError = dlerror();
215 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
216 __func__, lastError != nullptr ? lastError : "no error");
217
218 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
219 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
220 lastError = dlerror();
221 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
222 __func__, lastError != nullptr ? lastError : "no error");
223 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
224 unloadAudioPolicyManager();
225 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
226 }
227 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700228}
229
230void AudioPolicyService::onFirstRef()
231{
Andy Hungd47aca22022-03-15 11:50:51 -0700232 // Log an AudioPolicy "constructor" mediametrics event on first ref.
233 // This records the time it takes to load the audio modules and devices.
234 mediametrics::Defer defer([beginNs = systemTime()] {
235 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
236 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
237 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
238 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700239 {
240 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800241
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700242 // start audio commands thread
243 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
244 // start output activity command thread
245 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700246
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700247 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530248
249 loadAudioPolicyManager();
250 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700251 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200252
bryant_liuba2b4392014-06-11 16:49:30 +0800253 // load audio processing modules
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000254 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
255 sp<UidPolicy> uidPolicy = new UidPolicy(this);
256 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700257 {
258 Mutex::Autolock _l(mLock);
259 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000260 mUidPolicy = uidPolicy;
261 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700262 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000263 uidPolicy->registerSelf();
264 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200265
Eric Laurent81dd0f52021-07-05 11:54:40 +0200266 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200267 if (mAudioPolicyManager != nullptr) {
268 Mutex::Autolock _l(mLock);
269 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
270 AudioDeviceTypeAddrVector devices;
271 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
272 if (hasSpatializer) {
273 mSpatializer = Spatializer::create(this);
274 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200275 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200276 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700277}
278
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530279void AudioPolicyService::unloadAudioPolicyManager()
280{
281 ALOGV("%s ", __func__);
282 if (mLibraryHandle != nullptr) {
283 dlclose(mLibraryHandle);
284 }
285 mLibraryHandle = nullptr;
286 mCreateAudioPolicyManager = nullptr;
287 mDestroyAudioPolicyManager = nullptr;
288}
289
Mathias Agopian65ab4712010-07-14 17:59:35 -0700290AudioPolicyService::~AudioPolicyService()
291{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700292 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700293 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700294
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530295 mDestroyAudioPolicyManager(mAudioPolicyManager);
296 unloadAudioPolicyManager();
297
Eric Laurentdce54a12014-03-10 12:19:46 -0700298 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700299
300 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800301 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800302
303 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800304 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000305
306 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800307 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700308}
309
310// A notification client is always registered by AudioSystem when the client process
311// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800312Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700313{
Eric Laurent12590252015-08-21 18:40:20 -0700314 if (client == 0) {
315 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800316 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700317 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800318 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700319
320 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800321 pid_t pid = IPCThreadState::self()->getCallingPid();
322 int64_t token = ((int64_t)uid<<32) | pid;
323
324 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700325 sp<NotificationClient> notificationClient = new NotificationClient(this,
326 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800327 uid,
328 pid);
329 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700330
luochaojiang908c7d72018-06-21 14:58:04 +0800331 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700332
Marco Nelissenf8880202014-11-14 07:58:25 -0800333 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700334 binder->linkToDeath(notificationClient);
335 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800336 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700337}
338
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800339Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700340{
341 Mutex::Autolock _l(mNotificationClientsLock);
342
343 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800344 pid_t pid = IPCThreadState::self()->getCallingPid();
345 int64_t token = ((int64_t)uid<<32) | pid;
346
347 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800348 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700349 }
luochaojiang908c7d72018-06-21 14:58:04 +0800350 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800351 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700352}
353
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800354Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100355{
356 Mutex::Autolock _l(mNotificationClientsLock);
357
358 uid_t uid = IPCThreadState::self()->getCallingUid();
359 pid_t pid = IPCThreadState::self()->getCallingPid();
360 int64_t token = ((int64_t)uid<<32) | pid;
361
362 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800363 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100364 }
365 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800366 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100367}
368
Eric Laurentb52c1522014-05-20 11:27:36 -0700369// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800370void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700371{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000372 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800373 {
374 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800375 int64_t token = ((int64_t)uid<<32) | pid;
376 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800377 for (size_t i = 0; i < mNotificationClients.size(); i++) {
378 if (mNotificationClients.valueAt(i)->uid() == uid) {
379 hasSameUid = true;
380 break;
381 }
382 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000383 }
384 {
385 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800386 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700387 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700388 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700389 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800390 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700391}
392
393void AudioPolicyService::onAudioPortListUpdate()
394{
395 mOutputCommandThread->updateAudioPortListCommand();
396}
397
398void AudioPolicyService::doOnAudioPortListUpdate()
399{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800400 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700401 for (size_t i = 0; i < mNotificationClients.size(); i++) {
402 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
403 }
404}
405
406void AudioPolicyService::onAudioPatchListUpdate()
407{
408 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700409}
410
Eric Laurentb52c1522014-05-20 11:27:36 -0700411void AudioPolicyService::doOnAudioPatchListUpdate()
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)->onAudioPatchListUpdate();
416 }
417}
418
François Gaffiecfe17322018-11-07 13:41:29 +0100419void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
420{
421 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
422}
423
424void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
425{
426 Mutex::Autolock _l(mNotificationClientsLock);
427 for (size_t i = 0; i < mNotificationClients.size(); i++) {
428 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
429 }
430}
431
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700432void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700433{
434 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
435 regId.string(), state);
436 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
437}
438
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700439void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700440{
441 Mutex::Autolock _l(mNotificationClientsLock);
442 for (size_t i = 0; i < mNotificationClients.size(); i++) {
443 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
444 }
445}
446
Eric Laurenta9f86652018-11-28 17:23:11 -0800447void AudioPolicyService::onRecordingConfigurationUpdate(
448 int event,
449 const record_client_info_t *clientInfo,
450 const audio_config_base_t *clientConfig,
451 std::vector<effect_descriptor_t> clientEffects,
452 const audio_config_base_t *deviceConfig,
453 std::vector<effect_descriptor_t> effects,
454 audio_patch_handle_t patchHandle,
455 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800456{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800457 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800458 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800459}
460
Eric Laurenta9f86652018-11-28 17:23:11 -0800461void AudioPolicyService::doOnRecordingConfigurationUpdate(
462 int event,
463 const record_client_info_t *clientInfo,
464 const audio_config_base_t *clientConfig,
465 std::vector<effect_descriptor_t> clientEffects,
466 const audio_config_base_t *deviceConfig,
467 std::vector<effect_descriptor_t> effects,
468 audio_patch_handle_t patchHandle,
469 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800470{
471 Mutex::Autolock _l(mNotificationClientsLock);
472 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800473 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800474 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800475 }
476}
477
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700478void AudioPolicyService::onRoutingUpdated()
479{
480 mOutputCommandThread->routingChangedCommand();
481}
482
483void AudioPolicyService::doOnRoutingUpdated()
484{
485 Mutex::Autolock _l(mNotificationClientsLock);
486 for (size_t i = 0; i < mNotificationClients.size(); i++) {
487 mNotificationClients.valueAt(i)->onRoutingUpdated();
488 }
489}
490
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000491void AudioPolicyService::onVolumeRangeInitRequest()
492{
493 mOutputCommandThread->volRangeInitReqCommand();
494}
495
496void AudioPolicyService::doOnVolumeRangeInitRequest()
497{
498 Mutex::Autolock _l(mNotificationClientsLock);
499 for (size_t i = 0; i < mNotificationClients.size(); i++) {
500 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
501 }
502}
503
Eric Laurent81dd0f52021-07-05 11:54:40 +0200504void AudioPolicyService::onCheckSpatializer()
505{
506 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200507 onCheckSpatializer_l();
508}
509
510void AudioPolicyService::onCheckSpatializer_l()
511{
512 if (mSpatializer != nullptr) {
513 mOutputCommandThread->checkSpatializerCommand();
514 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200515}
516
517void AudioPolicyService::doOnCheckSpatializer()
518{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200519 ALOGV("%s mSpatializer %p level %d",
520 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200521
Eric Laurent39095982021-08-24 18:29:27 +0200522 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200523 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200524 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
525 audio_io_handle_t currentOutput = mSpatializer->getOutput();
526 audio_io_handle_t newOutput;
527 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
528 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200529
530 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200531 status_t status =
532 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100533 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
534 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200535 if (status == NO_ERROR && currentOutput == newOutput) {
536 return;
537 }
Eric Laurent15903592022-02-24 20:44:36 +0100538 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200539 mLock.unlock();
540 // It is OK to call detachOutput() is none is already attached.
541 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200542 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
543 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200544 }
Eric Laurent39095982021-08-24 18:29:27 +0200545 mLock.lock();
546 if (status != NO_ERROR) {
547 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
548 }
549 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
550 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200551 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200552
Eric Laurent39095982021-08-24 18:29:27 +0200553 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200554 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200555 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200556 }
557 }
558 }
559}
560
Eric Laurent11094172022-04-05 18:27:42 +0200561size_t AudioPolicyService::countActiveClientsOnOutput_l(
562 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100563 size_t count = 0;
564 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
565 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200566 if (client->io == output && client->active
567 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100568 count++;
569 }
570 }
571 return count;
572}
573
574void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
575 if (mSpatializer == nullptr) {
576 return;
577 }
578 mOutputCommandThread->updateActiveSpatializerTracksCommand();
579}
580
581void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
582{
Eric Laurent21270b62022-07-04 15:11:29 +0200583 if (mSpatializer == nullptr) {
584 return;
585 }
586 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200587 size_t activeClients;
588 {
589 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200590 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100591 }
Eric Laurent21270b62022-07-04 15:11:29 +0200592 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100593}
594
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800595status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
596 audio_patch_handle_t *handle,
597 int delayMs)
598{
599 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
600}
601
602status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
603 int delayMs)
604{
605 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
606}
607
Eric Laurente1715a42014-05-20 11:30:42 -0700608status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
609 int delayMs)
610{
611 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
612}
613
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800614AudioPolicyService::NotificationClient::NotificationClient(
615 const sp<AudioPolicyService>& service,
616 const sp<media::IAudioPolicyServiceClient>& client,
617 uid_t uid,
618 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800619 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100620 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700621{
622}
623
624AudioPolicyService::NotificationClient::~NotificationClient()
625{
626}
627
628void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
629{
630 sp<NotificationClient> keep(this);
631 sp<AudioPolicyService> service = mService.promote();
632 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800633 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700634 }
635}
636
637void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
638{
Eric Laurente8726fe2015-06-26 09:39:24 -0700639 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700640 mAudioPolicyServiceClient->onAudioPortListUpdate();
641 }
642}
643
644void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
645{
Eric Laurente8726fe2015-06-26 09:39:24 -0700646 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700647 mAudioPolicyServiceClient->onAudioPatchListUpdate();
648 }
649}
Eric Laurent57dae992011-07-24 13:36:09 -0700650
Pattydd807582021-11-04 21:01:03 +0800651void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100652 int flags)
653{
654 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
655 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
656 }
657}
658
659
Jean-Michel Trivide801052015-04-14 19:10:14 -0700660void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700661 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700662{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700663 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800664 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
665 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800666 }
667}
668
669void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800670 int event,
671 const record_client_info_t *clientInfo,
672 const audio_config_base_t *clientConfig,
673 std::vector<effect_descriptor_t> clientEffects,
674 const audio_config_base_t *deviceConfig,
675 std::vector<effect_descriptor_t> effects,
676 audio_patch_handle_t patchHandle,
677 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800678{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700679 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800680 status_t status = [&]() -> status_t {
681 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
682 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
683 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700684 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700685 legacy2aidl_audio_config_base_t_AudioConfigBase(
686 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800687 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
688 convertContainer<std::vector<media::EffectDescriptor>>(
689 clientEffects,
690 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700691 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700692 legacy2aidl_audio_config_base_t_AudioConfigBase(
693 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800694 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
695 convertContainer<std::vector<media::EffectDescriptor>>(
696 effects,
697 legacy2aidl_effect_descriptor_t_EffectDescriptor));
698 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
699 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700700 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
701 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800702 return aidl_utils::statusTFromBinderStatus(
703 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
704 clientInfoAidl,
705 clientConfigAidl,
706 clientEffectsAidl,
707 deviceConfigAidl,
708 effectsAidl,
709 patchHandleAidl,
710 sourceAidl));
711 }();
712 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700713 }
714}
715
Eric Laurente8726fe2015-06-26 09:39:24 -0700716void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
717{
718 mAudioPortCallbacksEnabled = enabled;
719}
720
François Gaffiecfe17322018-11-07 13:41:29 +0100721void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
722{
723 mAudioVolumeGroupCallbacksEnabled = enabled;
724}
Eric Laurente8726fe2015-06-26 09:39:24 -0700725
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700726void AudioPolicyService::NotificationClient::onRoutingUpdated()
727{
728 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
729 mAudioPolicyServiceClient->onRoutingUpdated();
730 }
731}
732
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000733void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
734{
735 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
736 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
737 }
738}
739
Mathias Agopian65ab4712010-07-14 17:59:35 -0700740void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700741 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700742 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700743}
744
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000745static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700746{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000747 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
748}
749
750static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
751{
752 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700753}
754
755status_t AudioPolicyService::dumpInternals(int fd)
756{
757 const size_t SIZE = 256;
758 char buffer[SIZE];
759 String8 result;
760
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000761 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800762 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000763 std::stringstream msg;
764 size_t i = 0;
765 for (auto usage : mSupportedSystemUsages) {
766 if (i++ != 0) msg << ", ";
767 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
768 msg << strUsage;
769 } else {
770 msg << usage << " (unknown)";
771 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800772 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000773 if (i == 0) {
774 msg << "None";
775 }
776 msg << std::endl;
777 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800778
Mathias Agopian65ab4712010-07-14 17:59:35 -0700779 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800780
781 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700782 return NO_ERROR;
783}
784
Eric Laurente8c8b432018-10-17 10:08:02 -0700785void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800786{
Eric Laurente8c8b432018-10-17 10:08:02 -0700787 Mutex::Autolock _l(mLock);
788 updateUidStates_l();
789}
790
791void AudioPolicyService::updateUidStates_l()
792{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800793// Go over all active clients and allow capture (does not force silence) in the
794// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800795// The client is in the active assistant list
796// AND is TOP
797// AND an accessibility service is TOP
798// AND source is either VOICE_RECOGNITION OR HOTWORD
799// OR there is no active privacy sensitive capture or call
800// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
801// AND source is VOICE_RECOGNITION OR HOTWORD
802// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800803// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700804// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800805// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800806// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800807// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
808// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800809// OR The client is an accessibility service
810// AND Is on TOP
811// AND the source is VOICE_RECOGNITION or HOTWORD
812// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700813// AND there is no active privacy sensitive capture or call
814// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800815// AND is on TOP
816// AND the source is VOICE_RECOGNITION or HOTWORD
817// OR the client source is virtual (remote submix, call audio TX or RX...)
818// OR the client source is HOTWORD
819// AND is on TOP
820// OR all active clients are using HOTWORD source
821// AND no call is active
822// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
823// OR the client is the current InputMethodService
824// AND a RTT call is active AND the source is VOICE_RECOGNITION
825// OR Any client
826// AND The assistant is not on TOP
827// AND is on TOP or latest started
828// AND there is no active privacy sensitive capture or call
829// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800830
Eric Laurent4e947da2019-10-17 15:24:06 -0700831
Eric Laurent4eb58f12018-12-07 16:41:02 -0800832 sp<AudioRecordClient> topActive;
833 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800834 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700835 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800836 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700837
Eric Laurenta46bedb2018-12-07 18:01:26 -0800838 nsecs_t topStartNs = 0;
839 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800840 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800841 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800842 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800843 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
844 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800845 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800846 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700847 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800848 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
849 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700850 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700851 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700852 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800853
Michael Groovercfd28302018-12-11 19:16:46 -0800854 // if Sensor Privacy is enabled then all recordings should be silenced.
855 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
856 silenceAllRecordings_l();
857 return;
858 }
859
Eric Laurente8c8b432018-10-17 10:08:02 -0700860 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
861 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000862 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
863 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800864 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700865 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800866 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700867
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700868 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700869 // clients which app is in IDLE state are not eligible for top active or
870 // latest active
871 if (appState == APP_STATE_IDLE) {
872 continue;
873 }
874
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700875 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700876 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800877 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700878 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700879 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800880 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800881 bool isPrivacySensitive =
882 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700883
Eric Laurentc21d5692020-02-25 10:24:36 -0800884 if (appState == APP_STATE_TOP) {
885 if (isPrivacySensitive) {
886 if (current->startTimeNs > topSensitiveStartNs) {
887 topSensitiveActive = current;
888 topSensitiveStartNs = current->startTimeNs;
889 }
890 } else {
891 if (current->startTimeNs > topStartNs) {
892 topActive = current;
893 topStartNs = current->startTimeNs;
894 }
895 }
896 if (isAssistant) {
897 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800898 if (isActiveAssistant) {
899 useActiveAssistantList = true;
900 } else if (!useActiveAssistantList) {
901 if (current->startTimeNs > latestAssistantStartNs) {
902 latestActiveAssistant = current;
903 latestAssistantStartNs = current->startTimeNs;
904 }
905 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800906 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800907 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800908 // Clients capturing for HOTWORD are not considered
909 // for latest active to avoid masking regular clients started before
910 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
911 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
912 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700913 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
914 // is marked latest sensitive active even if another app qualifies.
915 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700916 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700917 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700918 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000919 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700920 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700921 latestSensitiveActiveOrComm = current;
922 latestSensitiveStartNs = current->startTimeNs;
923 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800924 }
925 isSensitiveActive = true;
926 } else {
927 if (current->startTimeNs > latestStartNs) {
928 latestActive = current;
929 latestStartNs = current->startTimeNs;
930 }
931 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800932 }
933 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700934 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
935 onlyHotwordActive = false;
936 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100937 if (currentUid == mPhoneStateOwnerUid &&
938 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700939 isPhoneStateOwnerActive = true;
940 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800941 }
942
Eric Laurent1ff16a72019-03-14 18:35:04 -0700943 // if no active client with UI on Top, consider latest active as top
944 if (topActive == nullptr) {
945 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800946 topStartNs = latestStartNs;
947 }
948 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700949 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800950 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700951 } else if (latestSensitiveActiveOrComm != nullptr) {
952 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
953 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700954 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000955 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700956 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700957 topSensitiveActive = latestSensitiveActiveOrComm;
958 topSensitiveStartNs = latestSensitiveStartNs;
959 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800960 }
961
962 // If both privacy sensitive and regular capture are active:
963 // if the regular capture is privileged
964 // allow concurrency
965 // else
966 // favor the privacy sensitive case
967 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700968 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800969 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800970 }
971
972 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
973 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700974 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000975 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700976 if (!current->active) {
977 continue;
978 }
979
Eric Laurent4eb58f12018-12-07 16:41:02 -0800980 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700981 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000982 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700983 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000984 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800985 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
986 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -0800987
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000988 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700989 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000990 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -0700991 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -0700992 bool canCaptureCommunication = recordClient->canCaptureOutput
993 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700994 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -0700995 return !(isInCall && !canCaptureCall)
996 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -0800997 };
Eric Laurent1ff16a72019-03-14 18:35:04 -0700998
999 // By default allow capture if:
1000 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001001 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001002 // AND there is no active privacy sensitive capture or call
1003 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1004 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001005 && (isTopOrLatestActive || isTopOrLatestSensitive)
1006 && !(isSensitiveActive
Ricardo Correa57a37692020-03-23 17:27:25 -07001007 && !(isTopOrLatestSensitive || current->canCaptureOutput))
Eric Laurentc21d5692020-02-25 10:24:36 -08001008 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001009
Eric Laurented726cc2021-07-01 14:26:41 +02001010 if (!current->hasOp()) {
1011 // Never allow capture if app op is denied
1012 allowCapture = false;
1013 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001014 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1015 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001016 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001017 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001018 // Active assistant list is not being used
1019 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001020 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001021 // OR there is no active privacy sensitive capture or call
1022 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1023 // AND is latest TOP assistant AND
1024 // uses VOICE_RECOGNITION OR uses HOTWORD
1025 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001026 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001027 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001028 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001029 }
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001030 } else if (!(isSensitiveActive && !current->canCaptureOutput)
1031 && canCaptureIfInCallOrCommunication(current)) {
1032 if (isTopOrLatestAssistant
1033 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1034 || source == AUDIO_SOURCE_HOTWORD)) {
1035 allowCapture = true;
1036 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1037 allowCapture = true;
1038 }
1039 }
1040 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1041 // For assistant on active list and on top allow capture if:
1042 // An accessibility service is on TOP
1043 // AND the source is VOICE_RECOGNITION or HOTWORD
1044 // OR there is no active privacy sensitive capture or call
1045 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1046 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1047 if (isA11yOnTop) {
1048 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1049 allowCapture = true;
1050 }
1051 } else if (!(isSensitiveActive && !current->canCaptureOutput)
Eric Laurentc21d5692020-02-25 10:24:36 -08001052 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001053 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1054 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001055 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001056 }
1057 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001058 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001059 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001060 // The assistant is not on TOP
1061 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001062 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001063 // OR
1064 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1065 if (!isAssistantOnTop
Ricardo Correa57a37692020-03-23 17:27:25 -07001066 && !(isSensitiveActive && !current->canCaptureOutput)
Eric Laurentc21d5692020-02-25 10:24:36 -08001067 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001068 allowCapture = true;
1069 }
Eric Laurent589171c2019-07-25 18:04:29 -07001070 if (isA11yOnTop) {
1071 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1072 allowCapture = true;
1073 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001074 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001075 } else if (source == AUDIO_SOURCE_HOTWORD) {
1076 // For HOTWORD source allow capture when not on TOP if:
1077 // All active clients are using HOTWORD source
1078 // AND no call is active
1079 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001080 if (onlyHotwordActive
1081 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001082 allowCapture = true;
1083 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001084 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001085 // For current InputMethodService allow capture if:
1086 // A RTT call is active AND the source is VOICE_RECOGNITION
1087 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1088 allowCapture = true;
1089 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001090 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001091 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001092 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001093 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001094 }
1095}
1096
Michael Groovercfd28302018-12-11 19:16:46 -08001097void AudioPolicyService::silenceAllRecordings_l() {
1098 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1099 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001100 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001101 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001102 }
Michael Groovercfd28302018-12-11 19:16:46 -08001103 }
1104}
1105
Eric Laurente8c8b432018-10-17 10:08:02 -07001106/* static */
1107app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001108
1109 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001110 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001111 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1112 // include persistent services
1113 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001114 }
1115 return APP_STATE_FOREGROUND;
1116}
1117
Eric Laurent4eb58f12018-12-07 16:41:02 -08001118/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001119bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001120{
1121 switch (source) {
1122 case AUDIO_SOURCE_VOICE_UPLINK:
1123 case AUDIO_SOURCE_VOICE_DOWNLINK:
1124 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001125 case AUDIO_SOURCE_REMOTE_SUBMIX:
1126 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001127 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001128 return true;
1129 default:
1130 break;
1131 }
1132 return false;
1133}
1134
Eric Laurented726cc2021-07-01 14:26:41 +02001135/* static */
1136bool AudioPolicyService::isAppOpSource(audio_source_t source)
1137{
1138 switch (source) {
1139 case AUDIO_SOURCE_FM_TUNER:
1140 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001141 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001142 return false;
1143 default:
1144 break;
1145 }
1146 return true;
1147}
1148
Eric Laurent8c7ef892021-06-10 13:32:16 +02001149void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001150{
1151 AutoCallerClear acc;
1152
1153 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001154 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001155 }
1156 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1157 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001158 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001159 if (client->silenced != silenced) {
1160 if (client->active) {
1161 if (silenced) {
1162 finishRecording(client->attributionSource, client->attributes.source);
1163 } else {
1164 std::stringstream msg;
1165 msg << "Audio recording un-silenced on session " << client->session;
1166 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1167 client->attributes.source)) {
1168 silenced = true;
1169 }
1170 }
1171 }
1172 af->setRecordSilenced(client->portId, silenced);
1173 client->silenced = silenced;
1174 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001175 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001176}
1177
Glenn Kasten0f11b512014-01-31 16:18:54 -08001178status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001179{
Glenn Kasten44deb052012-02-05 18:09:08 -08001180 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001181 dumpPermissionDenial(fd);
1182 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001183 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001184 if (!locked) {
1185 String8 result(kDeadlockedString);
1186 write(fd, result.string(), result.size());
1187 }
1188
1189 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001190
1191 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1192 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001193 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001194 mAudioCommandThread->dump(fd);
1195 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001196
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001197 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1198 write(fd, octPtr.string(), octPtr.size());
1199 if (mOutputCommandThread != 0) {
1200 mOutputCommandThread->dump(fd);
1201 }
1202
Eric Laurentdce54a12014-03-10 12:19:46 -07001203 if (mAudioPolicyManager) {
1204 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001205 } else {
1206 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1207 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001208 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001209
Kevin Rocard8be94972019-02-22 13:26:25 -08001210 mPackageManager.dump(fd);
1211
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001212 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001213
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001214 if (mSpatializer != nullptr) {
1215 std::string dumpString = mSpatializer->toString(1 /* level */);
1216 write(fd, dumpString.c_str(), dumpString.size());
1217 } else {
1218 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1219 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1220 }
1221
Andy Hungc747c532022-03-07 21:41:14 -08001222 {
1223 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1224 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1225 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1226 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001227 }
1228 return NO_ERROR;
1229}
1230
1231status_t AudioPolicyService::dumpPermissionDenial(int fd)
1232{
1233 const size_t SIZE = 256;
1234 char buffer[SIZE];
1235 String8 result;
1236 snprintf(buffer, SIZE, "Permission Denial: "
1237 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1238 IPCThreadState::self()->getCallingPid(),
1239 IPCThreadState::self()->getCallingUid());
1240 result.append(buffer);
1241 write(fd, result.string(), result.size());
1242 return NO_ERROR;
1243}
1244
1245status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001246 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001247 // make sure transactions reserved to AudioFlinger do not come from other processes
1248 switch (code) {
1249 case TRANSACTION_startOutput:
1250 case TRANSACTION_stopOutput:
1251 case TRANSACTION_releaseOutput:
1252 case TRANSACTION_getInputForAttr:
1253 case TRANSACTION_startInput:
1254 case TRANSACTION_stopInput:
1255 case TRANSACTION_releaseInput:
1256 case TRANSACTION_getOutputForEffect:
1257 case TRANSACTION_registerEffect:
1258 case TRANSACTION_unregisterEffect:
1259 case TRANSACTION_setEffectEnabled:
1260 case TRANSACTION_getStrategyForStream:
1261 case TRANSACTION_getOutputForAttr:
1262 case TRANSACTION_moveEffectsToIo:
1263 ALOGW("%s: transaction %d received from PID %d",
1264 __func__, code, IPCThreadState::self()->getCallingPid());
1265 return INVALID_OPERATION;
1266 default:
1267 break;
1268 }
1269
1270 // make sure the following transactions come from system components
1271 switch (code) {
1272 case TRANSACTION_setDeviceConnectionState:
1273 case TRANSACTION_handleDeviceConfigChange:
1274 case TRANSACTION_setPhoneState:
1275//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1276// case TRANSACTION_setForceUse:
1277 case TRANSACTION_initStreamVolume:
1278 case TRANSACTION_setStreamVolumeIndex:
1279 case TRANSACTION_setVolumeIndexForAttributes:
1280 case TRANSACTION_getStreamVolumeIndex:
1281 case TRANSACTION_getVolumeIndexForAttributes:
1282 case TRANSACTION_getMinVolumeIndexForAttributes:
1283 case TRANSACTION_getMaxVolumeIndexForAttributes:
1284 case TRANSACTION_isStreamActive:
1285 case TRANSACTION_isStreamActiveRemotely:
1286 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001287 case TRANSACTION_registerPolicyMixes:
1288 case TRANSACTION_setMasterMono:
1289 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001290 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001291 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001292 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001293 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001294 case TRANSACTION_setA11yServicesUids:
1295 case TRANSACTION_setUidDeviceAffinities:
1296 case TRANSACTION_removeUidDeviceAffinities:
1297 case TRANSACTION_setUserIdDeviceAffinities:
1298 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001299 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001300 case TRANSACTION_listAudioVolumeGroups:
1301 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1302 case TRANSACTION_acquireSoundTriggerSession:
1303 case TRANSACTION_releaseSoundTriggerSession:
1304 case TRANSACTION_setRttEnabled:
1305 case TRANSACTION_isCallScreenModeSupported:
1306 case TRANSACTION_setDevicesRoleForStrategy:
1307 case TRANSACTION_setSupportedSystemUsages:
1308 case TRANSACTION_removeDevicesRoleForStrategy:
1309 case TRANSACTION_getDevicesForRoleAndStrategy:
1310 case TRANSACTION_getDevicesForAttributes:
1311 case TRANSACTION_setAllowedCapturePolicy:
1312 case TRANSACTION_onNewAudioModulesAvailable:
1313 case TRANSACTION_setCurrentImeUid:
1314 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1315 case TRANSACTION_setDevicesRoleForCapturePreset:
1316 case TRANSACTION_addDevicesRoleForCapturePreset:
1317 case TRANSACTION_removeDevicesRoleForCapturePreset:
1318 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001319 case TRANSACTION_getDevicesForRoleAndCapturePreset:
1320 case TRANSACTION_getSpatializer: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001321 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1322 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1323 __func__, code, IPCThreadState::self()->getCallingPid(),
1324 IPCThreadState::self()->getCallingUid());
1325 return INVALID_OPERATION;
1326 }
1327 } break;
1328 default:
1329 break;
1330 }
1331
Andy Hungc747c532022-03-07 21:41:14 -08001332 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1333 mediautils::TimeCheck check(
1334 std::string("IAudioPolicyService::").append(methodName),
1335 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1336 if (timeout) {
1337 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1338 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1339 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1340 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1341 .record();
1342 } else {
1343 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1344 }
1345 });
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001346
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001347 switch (code) {
1348 case SHELL_COMMAND_TRANSACTION: {
1349 int in = data.readFileDescriptor();
1350 int out = data.readFileDescriptor();
1351 int err = data.readFileDescriptor();
1352 int argc = data.readInt32();
1353 Vector<String16> args;
1354 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1355 args.add(data.readString16());
1356 }
1357 sp<IBinder> unusedCallback;
1358 sp<IResultReceiver> resultReceiver;
1359 status_t status;
1360 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1361 return status;
1362 }
1363 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1364 return status;
1365 }
1366 status = shellCommand(in, out, err, args);
1367 if (resultReceiver != nullptr) {
1368 resultReceiver->send(status);
1369 }
1370 return NO_ERROR;
1371 }
1372 }
1373
Mathias Agopian65ab4712010-07-14 17:59:35 -07001374 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1375}
1376
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001377// ------------------- Shell command implementation -------------------
1378
1379// NOTE: This is a remote API - make sure all args are validated
1380status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1381 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1382 return PERMISSION_DENIED;
1383 }
1384 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1385 return BAD_VALUE;
1386 }
jovanakbe066e12019-09-02 11:54:39 -07001387 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001388 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001389 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001390 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001391 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001392 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001393 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1394 purgePermissionCache();
1395 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001396 } else if (args.size() == 1 && args[0] == String16("help")) {
1397 printHelp(out);
1398 return NO_ERROR;
1399 }
1400 printHelp(err);
1401 return BAD_VALUE;
1402}
1403
jovanakbe066e12019-09-02 11:54:39 -07001404static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1405 if (userId < 0) {
1406 ALOGE("Invalid user: %d", userId);
1407 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001408 return BAD_VALUE;
1409 }
jovanakbe066e12019-09-02 11:54:39 -07001410
1411 PermissionController pc;
1412 uid = pc.getPackageUid(packageName, 0);
1413 if (uid <= 0) {
1414 ALOGE("Unknown package: '%s'", String8(packageName).string());
1415 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1416 return BAD_VALUE;
1417 }
1418
1419 uid = multiuser_get_uid(userId, uid);
1420 return NO_ERROR;
1421}
1422
1423status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1424 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1425 if (!(args.size() == 3 || args.size() == 5)) {
1426 printHelp(err);
1427 return BAD_VALUE;
1428 }
1429
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001430 bool active = false;
1431 if (args[2] == String16("active")) {
1432 active = true;
1433 } else if ((args[2] != String16("idle"))) {
1434 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1435 return BAD_VALUE;
1436 }
jovanakbe066e12019-09-02 11:54:39 -07001437
1438 int userId = 0;
1439 if (args.size() >= 5 && args[3] == String16("--user")) {
1440 userId = atoi(String8(args[4]));
1441 }
1442
1443 uid_t uid;
1444 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1445 return BAD_VALUE;
1446 }
1447
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001448 sp<UidPolicy> uidPolicy;
1449 {
1450 Mutex::Autolock _l(mLock);
1451 uidPolicy = mUidPolicy;
1452 }
1453 if (uidPolicy) {
1454 uidPolicy->addOverrideUid(uid, active);
1455 return NO_ERROR;
1456 }
1457 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001458}
1459
1460status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001461 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1462 if (!(args.size() == 2 || args.size() == 4)) {
1463 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001464 return BAD_VALUE;
1465 }
jovanakbe066e12019-09-02 11:54:39 -07001466
1467 int userId = 0;
1468 if (args.size() >= 4 && args[2] == String16("--user")) {
1469 userId = atoi(String8(args[3]));
1470 }
1471
1472 uid_t uid;
1473 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1474 return BAD_VALUE;
1475 }
1476
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001477 sp<UidPolicy> uidPolicy;
1478 {
1479 Mutex::Autolock _l(mLock);
1480 uidPolicy = mUidPolicy;
1481 }
1482 if (uidPolicy) {
1483 uidPolicy->removeOverrideUid(uid);
1484 return NO_ERROR;
1485 }
1486 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001487}
1488
1489status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001490 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1491 if (!(args.size() == 2 || args.size() == 4)) {
1492 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001493 return BAD_VALUE;
1494 }
jovanakbe066e12019-09-02 11:54:39 -07001495
1496 int userId = 0;
1497 if (args.size() >= 4 && args[2] == String16("--user")) {
1498 userId = atoi(String8(args[3]));
1499 }
1500
1501 uid_t uid;
1502 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1503 return BAD_VALUE;
1504 }
1505
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001506 sp<UidPolicy> uidPolicy;
1507 {
1508 Mutex::Autolock _l(mLock);
1509 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001510 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001511 if (uidPolicy) {
1512 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1513 }
1514 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001515}
1516
1517status_t AudioPolicyService::printHelp(int out) {
1518 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001519 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1520 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1521 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001522 " help print this message\n");
1523}
1524
1525// ----------- AudioPolicyService::UidPolicy implementation ----------
1526
1527void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001528 status_t res = mAm.linkToDeath(this);
1529 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001530 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001531 | ActivityManager::UID_OBSERVER_ACTIVE
1532 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001533 ActivityManager::PROCESS_STATE_UNKNOWN,
1534 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001535 if (!res) {
1536 Mutex::Autolock _l(mLock);
1537 mObserverRegistered = true;
1538 } else {
1539 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001540
Steven Moreland2f348142019-07-02 15:59:07 -07001541 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001542 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001543}
1544
1545void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001546 mAm.unlinkToDeath(this);
1547 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001548 Mutex::Autolock _l(mLock);
1549 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001550}
1551
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001552void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1553 Mutex::Autolock _l(mLock);
1554 mCachedUids.clear();
1555 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001556}
1557
Eric Laurente8c8b432018-10-17 10:08:02 -07001558void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001559 bool needToReregister = false;
1560 {
1561 Mutex::Autolock _l(mLock);
1562 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001563 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001564 if (needToReregister) {
1565 // Looks like ActivityManager has died previously, attempt to re-register.
1566 registerSelf();
1567 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001568}
1569
1570bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1571 if (isServiceUid(uid)) return true;
1572 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001573 {
1574 Mutex::Autolock _l(mLock);
1575 auto overrideIter = mOverrideUids.find(uid);
1576 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001577 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001578 }
1579 // In an absense of the ActivityManager, assume everything to be active.
1580 if (!mObserverRegistered) return true;
1581 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001582 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001583 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001584 }
1585 }
1586 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001587 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001588 {
1589 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001590 mCachedUids.insert(std::pair<uid_t,
1591 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1592 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001593 }
1594 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001595}
1596
Eric Laurente8c8b432018-10-17 10:08:02 -07001597int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1598 if (isServiceUid(uid)) {
1599 return ActivityManager::PROCESS_STATE_TOP;
1600 }
1601 checkRegistered();
1602 {
1603 Mutex::Autolock _l(mLock);
1604 auto overrideIter = mOverrideUids.find(uid);
1605 if (overrideIter != mOverrideUids.end()) {
1606 if (overrideIter->second.first) {
1607 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1608 return overrideIter->second.second;
1609 } else {
1610 auto cacheIter = mCachedUids.find(uid);
1611 if (cacheIter != mCachedUids.end()) {
1612 return cacheIter->second.second;
1613 }
1614 }
1615 }
1616 return ActivityManager::PROCESS_STATE_UNKNOWN;
1617 }
1618 // In an absense of the ActivityManager, assume everything to be active.
1619 if (!mObserverRegistered) {
1620 return ActivityManager::PROCESS_STATE_TOP;
1621 }
1622 auto cacheIter = mCachedUids.find(uid);
1623 if (cacheIter != mCachedUids.end()) {
1624 if (cacheIter->second.first) {
1625 return cacheIter->second.second;
1626 } else {
1627 return ActivityManager::PROCESS_STATE_UNKNOWN;
1628 }
1629 }
1630 }
1631 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001632 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001633 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1634 if (active) {
1635 state = am.getUidProcessState(uid, String16("audioserver"));
1636 }
1637 {
1638 Mutex::Autolock _l(mLock);
1639 mCachedUids.insert(std::pair<uid_t,
1640 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1641 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001642
Eric Laurente8c8b432018-10-17 10:08:02 -07001643 return state;
1644}
1645
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001646void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001647 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001648}
1649
1650void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001651 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001652}
1653
1654void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001655 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001656}
1657
Eric Laurente8c8b432018-10-17 10:08:02 -07001658void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1659 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001660 int64_t procStateSeq __unused,
1661 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001662 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1663 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001664 }
1665}
1666
Austin Borger65577682022-02-17 00:25:43 +00001667void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1668}
1669
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001670void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001671 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1672}
1673
1674void AudioPolicyService::UidPolicy::notifyService() {
1675 sp<AudioPolicyService> service = mService.promote();
1676 if (service != nullptr) {
1677 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001678 }
1679}
1680
Eric Laurente8c8b432018-10-17 10:08:02 -07001681void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1682 std::pair<bool, int>> *uids,
1683 uid_t uid,
1684 bool active,
1685 int state,
1686 bool insert) {
1687 if (isServiceUid(uid)) {
1688 return;
1689 }
1690 bool wasActive = isUidActive(uid);
1691 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001692 {
1693 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001694 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001695 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001696 if (wasActive != isUidActive(uid) || state != previousState) {
1697 notifyService();
1698 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001699}
1700
Eric Laurente8c8b432018-10-17 10:08:02 -07001701void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1702 std::pair<bool, int>> *uids,
1703 uid_t uid,
1704 bool active,
1705 int state,
1706 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001707 auto it = uids->find(uid);
1708 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001709 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001710 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1711 it->second.first = active;
1712 }
1713 if (it->second.first) {
1714 it->second.second = state;
1715 } else {
1716 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1717 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001718 } else {
1719 uids->erase(it);
1720 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001721 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1722 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1723 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001724 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001725}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001726
Eric Laurent4eb58f12018-12-07 16:41:02 -08001727bool AudioPolicyService::UidPolicy::isA11yOnTop() {
1728 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001729 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001730 continue;
1731 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001732 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1733 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001734 return true;
1735 }
1736 }
1737 return false;
1738}
1739
Eric Laurentb78763e2018-10-17 10:08:02 -07001740bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1741{
1742 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1743 return it != mA11yUids.end();
1744}
1745
Oscar Azucena829d90d2022-01-28 17:17:56 -08001746void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1747 mAssistantUids.clear();
1748 mAssistantUids = uids;
1749}
1750
1751bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1752{
1753 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1754 return it != mAssistantUids.end();
1755}
1756
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001757void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1758 mActiveAssistantUids = activeUids;
1759}
1760
1761bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1762{
1763 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1764 mActiveAssistantUids.end(), uid);
1765 return it != mActiveAssistantUids.end();
1766}
1767
Oscar Azucena829d90d2022-01-28 17:17:56 -08001768void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1769 const size_t SIZE = 256;
1770 char buffer[SIZE];
1771 String8 result;
1772 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1773 snprintf(buffer, SIZE, "\t%s: \n", title);
1774 result.append(buffer);
1775 int counter = 0;
1776 if (uids.empty()) {
1777 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1778 result.append(buffer);
1779 return;
1780 }
1781 for (const auto &uid : uids) {
1782 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1783 result.append(buffer);
1784 }
1785 };
1786
1787 snprintf(buffer, SIZE, "UID Policy:\n");
1788 result.append(buffer);
1789 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1790 result.append(buffer);
1791
1792 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001793 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001794
1795 appendUidsToResult("Accessibility UIDs", mA11yUids);
1796
1797 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1798 result.append(buffer);
1799
1800 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1801 result.append(buffer);
1802
1803 write(fd, result.string(), result.size());
1804}
1805
Michael Groovercfd28302018-12-11 19:16:46 -08001806// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1807void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1808 SensorPrivacyManager spm;
1809 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1810 spm.addSensorPrivacyListener(this);
1811}
1812
1813void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1814 SensorPrivacyManager spm;
1815 spm.removeSensorPrivacyListener(this);
1816}
1817
1818bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1819 return mSensorPrivacyEnabled;
1820}
1821
Evan Seversond8dc6832022-01-27 10:47:03 -08001822binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1823 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001824 mSensorPrivacyEnabled = enabled;
1825 sp<AudioPolicyService> service = mService.promote();
1826 if (service != nullptr) {
1827 service->updateUidStates();
1828 }
1829 return binder::Status::ok();
1830}
1831
Eric Laurented726cc2021-07-01 14:26:41 +02001832// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1833
1834// static
1835sp<AudioPolicyService::OpRecordAudioMonitor>
1836AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1837 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1838 wp<AudioCommandThread> commandThread)
1839{
Eric Laurent987ce102021-07-05 12:11:51 +02001840 if (isAudioServerOrRootUid(attributionSource.uid)) {
1841 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001842 attributionSource.toString().c_str());
1843 return nullptr;
1844 }
1845
1846 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1847 ALOGD("not monitoring app op for uid %d and source %d",
1848 attributionSource.uid, attr.source);
1849 return nullptr;
1850 }
1851
1852 if (!attributionSource.packageName.has_value()
1853 || attributionSource.packageName.value().size() == 0) {
1854 return nullptr;
1855 }
1856 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1857}
1858
1859AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1860 const AttributionSourceState& attributionSource, int32_t appOp,
1861 wp<AudioCommandThread> commandThread) :
1862 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1863 mCommandThread(commandThread)
1864{
1865}
1866
1867AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1868{
1869 if (mOpCallback != 0) {
1870 mAppOpsManager.stopWatchingMode(mOpCallback);
1871 }
1872 mOpCallback.clear();
1873}
1874
1875void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1876{
1877 checkOp();
1878 mOpCallback = new RecordAudioOpCallback(this);
1879 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1880 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1881 // since it controls the mic permission for legacy apps.
1882 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1883 mAttributionSource.packageName.value_or(""))),
1884 mOpCallback);
1885}
1886
1887bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1888 return mHasOp.load();
1889}
1890
1891// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1892// is updated in AppOp callback and in onFirstRef()
1893// Note this method is never called (and never to be) for audio server / root track
1894// due to the UID in createIfNeeded(). As a result for those record track, it's:
1895// - not called from constructor,
1896// - not called from RecordAudioOpCallback because the callback is not installed in this case
1897void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1898{
1899 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1900 // since it controls the mic permission for legacy apps.
1901 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1902 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1903 mAttributionSource.packageName.value_or(""))));
1904 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1905 // verbose logging only log when appOp changed
1906 ALOGI_IF(hasIt != mHasOp.load(),
1907 "App op %d missing, %ssilencing record %s",
1908 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1909 mHasOp.store(hasIt);
1910
1911 if (updateUidStates) {
1912 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1913 if (commandThread != nullptr) {
1914 commandThread->updateUidStatesCommand();
1915 }
1916 }
1917}
1918
1919AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1920 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1921{ }
1922
1923void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1924 const String16& packageName __unused) {
1925 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1926 if (monitor != NULL) {
1927 if (op != monitor->getOp()) {
1928 return;
1929 }
1930 monitor->checkOp(true);
1931 }
1932}
1933
1934
Mathias Agopian65ab4712010-07-14 17:59:35 -07001935// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1936
Eric Laurentbfb1b832013-01-07 09:53:42 -08001937AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1938 const wp<AudioPolicyService>& service)
1939 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001940{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001941}
1942
1943
1944AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1945{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001946 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001947 release_wake_lock(mName.string());
1948 }
1949 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001950}
1951
1952void AudioPolicyService::AudioCommandThread::onFirstRef()
1953{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001954 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001955}
1956
1957bool AudioPolicyService::AudioCommandThread::threadLoop()
1958{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001959 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001960
1961 mLock.lock();
1962 while (!exitPending())
1963 {
Eric Laurent59a89232014-06-08 14:14:17 -07001964 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001965 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001966 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001967 nsecs_t curTime = systemTime();
1968 // commands are sorted by increasing time stamp: execute them from index 0 and up
1969 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001970 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001971 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001972 if (mAudioCommands.isEmpty()) {
1973 ++numTimesBecameEmpty;
1974 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001975 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001976
1977 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001978 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001979 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001980 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001981 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001982 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001983 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1984 data->mVolume,
1985 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001986 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001987 }break;
1988 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001989 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001990 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
1991 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001992 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001993 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07001994 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001995 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001996 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001997 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001998 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001999 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002000 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002001 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002002 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002003 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002004 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002005 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002006 ALOGV("AudioCommandThread() processing stop output portId %d",
2007 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002008 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002009 if (svc == 0) {
2010 break;
2011 }
2012 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002013 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002014 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002015 }break;
2016 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002017 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002018 ALOGV("AudioCommandThread() processing release output portId %d",
2019 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002020 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002021 if (svc == 0) {
2022 break;
2023 }
2024 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002025 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002026 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002027 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002028 case CREATE_AUDIO_PATCH: {
2029 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2030 ALOGV("AudioCommandThread() processing create audio patch");
2031 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2032 if (af == 0) {
2033 command->mStatus = PERMISSION_DENIED;
2034 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002035 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002036 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002037 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002038 }
2039 } break;
2040 case RELEASE_AUDIO_PATCH: {
2041 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2042 ALOGV("AudioCommandThread() processing release audio patch");
2043 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2044 if (af == 0) {
2045 command->mStatus = PERMISSION_DENIED;
2046 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002047 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002048 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002049 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002050 }
2051 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002052 case UPDATE_AUDIOPORT_LIST: {
2053 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002054 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002055 if (svc == 0) {
2056 break;
2057 }
2058 mLock.unlock();
2059 svc->doOnAudioPortListUpdate();
2060 mLock.lock();
2061 }break;
2062 case UPDATE_AUDIOPATCH_LIST: {
2063 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002064 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002065 if (svc == 0) {
2066 break;
2067 }
2068 mLock.unlock();
2069 svc->doOnAudioPatchListUpdate();
2070 mLock.lock();
2071 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002072 case CHANGED_AUDIOVOLUMEGROUP: {
2073 AudioVolumeGroupData *data =
2074 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2075 ALOGV("AudioCommandThread() processing update audio volume group");
2076 svc = mService.promote();
2077 if (svc == 0) {
2078 break;
2079 }
2080 mLock.unlock();
2081 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2082 mLock.lock();
2083 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002084 case SET_AUDIOPORT_CONFIG: {
2085 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2086 ALOGV("AudioCommandThread() processing set port config");
2087 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2088 if (af == 0) {
2089 command->mStatus = PERMISSION_DENIED;
2090 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002091 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002092 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002093 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002094 }
2095 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002096 case DYN_POLICY_MIX_STATE_UPDATE: {
2097 DynPolicyMixStateUpdateData *data =
2098 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002099 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2100 data->mRegId.string(), data->mState);
2101 svc = mService.promote();
2102 if (svc == 0) {
2103 break;
2104 }
2105 mLock.unlock();
2106 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2107 mLock.lock();
2108 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002109 case RECORDING_CONFIGURATION_UPDATE: {
2110 RecordingConfigurationUpdateData *data =
2111 (RecordingConfigurationUpdateData *)command->mParam.get();
2112 ALOGV("AudioCommandThread() processing recording configuration update");
2113 svc = mService.promote();
2114 if (svc == 0) {
2115 break;
2116 }
2117 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002118 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002119 &data->mClientConfig, data->mClientEffects,
2120 &data->mDeviceConfig, data->mEffects,
2121 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002122 mLock.lock();
2123 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002124 case SET_EFFECT_SUSPENDED: {
2125 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2126 ALOGV("AudioCommandThread() processing set effect suspended");
2127 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2128 if (af != 0) {
2129 mLock.unlock();
2130 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2131 mLock.lock();
2132 }
2133 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002134 case AUDIO_MODULES_UPDATE: {
2135 ALOGV("AudioCommandThread() processing audio modules update");
2136 svc = mService.promote();
2137 if (svc == 0) {
2138 break;
2139 }
2140 mLock.unlock();
2141 svc->doOnNewAudioModulesAvailable();
2142 mLock.lock();
2143 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002144 case ROUTING_UPDATED: {
2145 ALOGV("AudioCommandThread() processing routing update");
2146 svc = mService.promote();
2147 if (svc == 0) {
2148 break;
2149 }
2150 mLock.unlock();
2151 svc->doOnRoutingUpdated();
2152 mLock.lock();
2153 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002154
Eric Laurented726cc2021-07-01 14:26:41 +02002155 case UPDATE_UID_STATES: {
2156 ALOGV("AudioCommandThread() processing updateUID states");
2157 svc = mService.promote();
2158 if (svc == 0) {
2159 break;
2160 }
2161 mLock.unlock();
2162 svc->updateUidStates();
2163 mLock.lock();
2164 } break;
2165
Eric Laurent15903592022-02-24 20:44:36 +01002166 case CHECK_SPATIALIZER_OUTPUT: {
2167 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002168 svc = mService.promote();
2169 if (svc == 0) {
2170 break;
2171 }
2172 mLock.unlock();
2173 svc->doOnCheckSpatializer();
2174 mLock.lock();
2175 } break;
2176
Eric Laurent15903592022-02-24 20:44:36 +01002177 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2178 ALOGV("AudioCommandThread() processing update spatializer tracks");
2179 svc = mService.promote();
2180 if (svc == 0) {
2181 break;
2182 }
2183 mLock.unlock();
2184 svc->doOnUpdateActiveSpatializerTracks();
2185 mLock.lock();
2186 } break;
2187
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002188 case VOL_RANGE_INIT_REQUEST: {
2189 ALOGV("AudioCommandThread() processing volume range init request");
2190 svc = mService.promote();
2191 if (svc == 0) {
2192 break;
2193 }
2194 mLock.unlock();
2195 svc->doOnVolumeRangeInitRequest();
2196 mLock.lock();
2197 } break;
2198
Mathias Agopian65ab4712010-07-14 17:59:35 -07002199 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002200 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002201 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002202 {
2203 Mutex::Autolock _l(command->mLock);
2204 if (command->mWaitStatus) {
2205 command->mWaitStatus = false;
2206 command->mCond.signal();
2207 }
2208 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002209 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002210 // release mLock before releasing strong reference on the service as
2211 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2212 // acquires mLock.
2213 mLock.unlock();
2214 svc.clear();
2215 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002216 } else {
2217 waitTime = mAudioCommands[0]->mTime - curTime;
2218 break;
2219 }
2220 }
Zach Janga754b4f2015-10-27 01:29:34 +00002221
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002222 // release delayed commands wake lock as many times as we made the queue is
2223 // empty during popping.
2224 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002225 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002226 }
2227
2228 // At this stage we have either an empty command queue or the first command in the queue
2229 // has a finite delay. So unless we are exiting it is safe to wait.
2230 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002231 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002232 if (waitTime == -1) {
2233 mWaitWorkCV.wait(mLock);
2234 } else {
2235 mWaitWorkCV.waitRelative(mLock, waitTime);
2236 }
Eric Laurent59a89232014-06-08 14:14:17 -07002237 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002238 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002239 // release delayed commands wake lock before quitting
2240 if (!mAudioCommands.isEmpty()) {
2241 release_wake_lock(mName.string());
2242 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002243 mLock.unlock();
2244 return false;
2245}
2246
2247status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2248{
2249 const size_t SIZE = 256;
2250 char buffer[SIZE];
2251 String8 result;
2252
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002253 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002254 if (!locked) {
2255 String8 result2(kCmdDeadlockedString);
2256 write(fd, result2.string(), result2.size());
2257 }
2258
2259 snprintf(buffer, SIZE, "- Commands:\n");
2260 result = String8(buffer);
2261 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002262 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002263 mAudioCommands[i]->dump(buffer, SIZE);
2264 result.append(buffer);
2265 }
2266 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002267 if (mLastCommand != 0) {
2268 mLastCommand->dump(buffer, SIZE);
2269 result.append(buffer);
2270 } else {
2271 result.append(" none\n");
2272 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002273
2274 write(fd, result.string(), result.size());
2275
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002276 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002277
2278 return NO_ERROR;
2279}
2280
Glenn Kastenfff6d712012-01-12 16:38:12 -08002281status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002282 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002283 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002284 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002285{
Eric Laurent0ede8922014-05-09 18:04:42 -07002286 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002287 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002288 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002289 data->mStream = stream;
2290 data->mVolume = volume;
2291 data->mIO = output;
2292 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002293 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002294 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002295 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002296 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002297}
2298
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002299status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002300 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002301 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002302{
Eric Laurent0ede8922014-05-09 18:04:42 -07002303 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002304 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002305 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002306 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002307 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002308 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002309 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002310 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002311 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002312 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002313}
2314
2315status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2316{
Eric Laurent0ede8922014-05-09 18:04:42 -07002317 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002318 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002319 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002320 data->mVolume = volume;
2321 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002322 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002323 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002324 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002325}
2326
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002327void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2328 audio_session_t sessionId,
2329 bool suspended)
2330{
2331 sp<AudioCommand> command = new AudioCommand();
2332 command->mCommand = SET_EFFECT_SUSPENDED;
2333 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2334 data->mEffectId = effectId;
2335 data->mSessionId = sessionId;
2336 data->mSuspended = suspended;
2337 command->mParam = data;
2338 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2339 effectId, sessionId, suspended);
2340 sendCommand(command);
2341}
2342
2343
Eric Laurentd7fe0862018-07-14 16:48:01 -07002344void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002345{
Eric Laurent0ede8922014-05-09 18:04:42 -07002346 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002347 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002348 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002349 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002350 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002351 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002352 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002353}
2354
Eric Laurentd7fe0862018-07-14 16:48:01 -07002355void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002356{
Eric Laurent0ede8922014-05-09 18:04:42 -07002357 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002358 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002359 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002360 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002361 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002362 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002363 sendCommand(command);
2364}
2365
Eric Laurent951f4552014-05-20 10:48:17 -07002366status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2367 const struct audio_patch *patch,
2368 audio_patch_handle_t *handle,
2369 int delayMs)
2370{
2371 status_t status = NO_ERROR;
2372
2373 sp<AudioCommand> command = new AudioCommand();
2374 command->mCommand = CREATE_AUDIO_PATCH;
2375 CreateAudioPatchData *data = new CreateAudioPatchData();
2376 data->mPatch = *patch;
2377 data->mHandle = *handle;
2378 command->mParam = data;
2379 command->mWaitStatus = true;
2380 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2381 status = sendCommand(command, delayMs);
2382 if (status == NO_ERROR) {
2383 *handle = data->mHandle;
2384 }
2385 return status;
2386}
2387
2388status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2389 int delayMs)
2390{
2391 sp<AudioCommand> command = new AudioCommand();
2392 command->mCommand = RELEASE_AUDIO_PATCH;
2393 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2394 data->mHandle = handle;
2395 command->mParam = data;
2396 command->mWaitStatus = true;
2397 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2398 return sendCommand(command, delayMs);
2399}
2400
Eric Laurentb52c1522014-05-20 11:27:36 -07002401void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2402{
2403 sp<AudioCommand> command = new AudioCommand();
2404 command->mCommand = UPDATE_AUDIOPORT_LIST;
2405 ALOGV("AudioCommandThread() adding update audio port list");
2406 sendCommand(command);
2407}
2408
Eric Laurented726cc2021-07-01 14:26:41 +02002409void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2410{
2411 sp<AudioCommand> command = new AudioCommand();
2412 command->mCommand = UPDATE_UID_STATES;
2413 ALOGV("AudioCommandThread() adding update UID states");
2414 sendCommand(command);
2415}
2416
Eric Laurentb52c1522014-05-20 11:27:36 -07002417void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2418{
2419 sp<AudioCommand>command = new AudioCommand();
2420 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2421 ALOGV("AudioCommandThread() adding update audio patch list");
2422 sendCommand(command);
2423}
2424
François Gaffiecfe17322018-11-07 13:41:29 +01002425void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2426 int flags)
2427{
2428 sp<AudioCommand>command = new AudioCommand();
2429 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2430 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2431 data->mGroup = group;
2432 data->mFlags = flags;
2433 command->mParam = data;
2434 ALOGV("AudioCommandThread() adding audio volume group changed");
2435 sendCommand(command);
2436}
2437
Eric Laurente1715a42014-05-20 11:30:42 -07002438status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2439 const struct audio_port_config *config, int delayMs)
2440{
2441 sp<AudioCommand> command = new AudioCommand();
2442 command->mCommand = SET_AUDIOPORT_CONFIG;
2443 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2444 data->mConfig = *config;
2445 command->mParam = data;
2446 command->mWaitStatus = true;
2447 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2448 return sendCommand(command, delayMs);
2449}
2450
Jean-Michel Trivide801052015-04-14 19:10:14 -07002451void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002452 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002453{
2454 sp<AudioCommand> command = new AudioCommand();
2455 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2456 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2457 data->mRegId = regId;
2458 data->mState = state;
2459 command->mParam = data;
2460 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2461 regId.string(), state);
2462 sendCommand(command);
2463}
2464
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002465void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002466 int event,
2467 const record_client_info_t *clientInfo,
2468 const audio_config_base_t *clientConfig,
2469 std::vector<effect_descriptor_t> clientEffects,
2470 const audio_config_base_t *deviceConfig,
2471 std::vector<effect_descriptor_t> effects,
2472 audio_patch_handle_t patchHandle,
2473 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002474{
2475 sp<AudioCommand>command = new AudioCommand();
2476 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2477 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2478 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002479 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002480 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002481 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002482 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002483 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002484 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002485 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002486 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002487 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2488 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002489 sendCommand(command);
2490}
2491
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002492void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2493{
2494 sp<AudioCommand> command = new AudioCommand();
2495 command->mCommand = AUDIO_MODULES_UPDATE;
2496 sendCommand(command);
2497}
2498
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002499void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2500{
2501 sp<AudioCommand>command = new AudioCommand();
2502 command->mCommand = ROUTING_UPDATED;
2503 ALOGV("AudioCommandThread() adding routing update");
2504 sendCommand(command);
2505}
2506
Eric Laurent81dd0f52021-07-05 11:54:40 +02002507void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2508{
2509 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002510 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002511 ALOGV("AudioCommandThread() adding check spatializer");
2512 sendCommand(command);
2513}
2514
Eric Laurent15903592022-02-24 20:44:36 +01002515void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2516{
2517 sp<AudioCommand>command = new AudioCommand();
2518 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2519 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2520 sendCommand(command);
2521}
2522
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002523void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2524{
2525 sp<AudioCommand>command = new AudioCommand();
2526 command->mCommand = VOL_RANGE_INIT_REQUEST;
2527 ALOGV("AudioCommandThread() adding volume range init request");
2528 sendCommand(command);
2529}
2530
Eric Laurent0ede8922014-05-09 18:04:42 -07002531status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2532{
2533 {
2534 Mutex::Autolock _l(mLock);
2535 insertCommand_l(command, delayMs);
2536 mWaitWorkCV.signal();
2537 }
2538 Mutex::Autolock _l(command->mLock);
2539 while (command->mWaitStatus) {
2540 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2541 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2542 command->mStatus = TIMED_OUT;
2543 command->mWaitStatus = false;
2544 }
2545 }
2546 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002547}
2548
Mathias Agopian65ab4712010-07-14 17:59:35 -07002549// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002550void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002551{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002552 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002553 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002554 command->mTime = systemTime() + milliseconds(delayMs);
2555
2556 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002557 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002558 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2559 }
2560
2561 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002562 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002563 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002564 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2565 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002566
2567 // create audio patch or release audio patch commands are equivalent
2568 // with regard to filtering
2569 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2570 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2571 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2572 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2573 continue;
2574 }
2575 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002576
2577 switch (command->mCommand) {
2578 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002579 ParametersData *data = (ParametersData *)command->mParam.get();
2580 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002581 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002582 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002583 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002584 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2585 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2586 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002587 String8 key;
2588 String8 value;
2589 param.getAt(j, key, value);
2590 for (size_t k = 0; k < param2.size(); k++) {
2591 String8 key2;
2592 String8 value2;
2593 param2.getAt(k, key2, value2);
2594 if (key2 == key) {
2595 param2.remove(key2);
2596 ALOGV("Filtering out parameter %s", key2.string());
2597 break;
2598 }
2599 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002600 }
2601 // if all keys have been filtered out, remove the command.
2602 // otherwise, update the key value pairs
2603 if (param2.size() == 0) {
2604 removedCommands.add(command2);
2605 } else {
2606 data2->mKeyValuePairs = param2.toString();
2607 }
Eric Laurent21e54562013-09-23 12:08:05 -07002608 command->mTime = command2->mTime;
2609 // force delayMs to non 0 so that code below does not request to wait for
2610 // command status as the command is now delayed
2611 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002612 } break;
2613
2614 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002615 VolumeData *data = (VolumeData *)command->mParam.get();
2616 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002617 if (data->mIO != data2->mIO) break;
2618 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002619 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002620 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002621 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002622 command->mTime = command2->mTime;
2623 // force delayMs to non 0 so that code below does not request to wait for
2624 // command status as the command is now delayed
2625 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002626 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002627
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002628 case SET_VOICE_VOLUME: {
2629 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2630 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2631 ALOGV("Filtering out voice volume command value %f replaced by %f",
2632 data2->mVolume, data->mVolume);
2633 removedCommands.add(command2);
2634 command->mTime = command2->mTime;
2635 // force delayMs to non 0 so that code below does not request to wait for
2636 // command status as the command is now delayed
2637 delayMs = 1;
2638 } break;
2639
Eric Laurente45b48a2014-09-04 16:40:57 -07002640 case CREATE_AUDIO_PATCH:
2641 case RELEASE_AUDIO_PATCH: {
2642 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002643 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002644 if (command->mCommand == CREATE_AUDIO_PATCH) {
2645 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002646 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002647 } else {
2648 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002649 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002650 }
2651 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002652 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002653 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2654 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002655 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002656 } else {
2657 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002658 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002659 }
2660 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002661 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2662 same output. */
2663 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2664 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2665 bool isOutputDiff = false;
2666 if (patch.num_sources == patch2.num_sources) {
2667 for (unsigned count = 0; count < patch.num_sources; count++) {
2668 if (patch.sources[count].id != patch2.sources[count].id) {
2669 isOutputDiff = true;
2670 break;
2671 }
2672 }
2673 if (isOutputDiff)
2674 break;
2675 }
2676 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002677 ALOGV("Filtering out %s audio patch command for handle %d",
2678 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2679 removedCommands.add(command2);
2680 command->mTime = command2->mTime;
2681 // force delayMs to non 0 so that code below does not request to wait for
2682 // command status as the command is now delayed
2683 delayMs = 1;
2684 } break;
2685
Jean-Michel Trivide801052015-04-14 19:10:14 -07002686 case DYN_POLICY_MIX_STATE_UPDATE: {
2687
2688 } break;
2689
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002690 case RECORDING_CONFIGURATION_UPDATE: {
2691
2692 } break;
2693
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002694 case ROUTING_UPDATED: {
2695
2696 } break;
2697
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002698 case VOL_RANGE_INIT_REQUEST: {
2699 // command may come from different requests, do not filter
2700 } break;
2701
Mathias Agopian65ab4712010-07-14 17:59:35 -07002702 default:
2703 break;
2704 }
2705 }
2706
2707 // remove filtered commands
2708 for (size_t j = 0; j < removedCommands.size(); j++) {
2709 // removed commands always have time stamps greater than current command
2710 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002711 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002712 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002713 mAudioCommands.removeAt(k);
2714 break;
2715 }
2716 }
2717 }
2718 removedCommands.clear();
2719
Eric Laurentaa79bef2015-01-15 14:33:51 -08002720 // Disable wait for status if delay is not 0.
2721 // Except for create audio patch command because the returned patch handle
2722 // is needed by audio policy manager
2723 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002724 command->mWaitStatus = false;
2725 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002726
Mathias Agopian65ab4712010-07-14 17:59:35 -07002727 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002728 ALOGV("inserting command: %d at index %zd, num commands %zu",
2729 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002730 mAudioCommands.insertAt(command, i + 1);
2731}
2732
2733void AudioPolicyService::AudioCommandThread::exit()
2734{
Steve Block3856b092011-10-20 11:56:00 +01002735 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002736 {
2737 AutoMutex _l(mLock);
2738 requestExit();
2739 mWaitWorkCV.signal();
2740 }
Zach Janga754b4f2015-10-27 01:29:34 +00002741 // Note that we can call it from the thread loop if all other references have been released
2742 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002743 requestExitAndWait();
2744}
2745
2746void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2747{
2748 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2749 mCommand,
2750 (int)ns2s(mTime),
2751 (int)ns2ms(mTime)%1000,
2752 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002753 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002754}
2755
Dima Zavinfce7a472011-04-19 22:30:36 -07002756/******* helpers for the service_ops callbacks defined below *********/
2757void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2758 const char *keyValuePairs,
2759 int delayMs)
2760{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002761 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002762 delayMs);
2763}
2764
2765int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2766 float volume,
2767 audio_io_handle_t output,
2768 int delayMs)
2769{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002770 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002771 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002772}
2773
Dima Zavinfce7a472011-04-19 22:30:36 -07002774int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2775{
2776 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2777}
2778
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002779void AudioPolicyService::setEffectSuspended(int effectId,
2780 audio_session_t sessionId,
2781 bool suspended)
2782{
2783 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2784}
2785
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002786Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002787{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002788 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002789 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002790}
2791
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002792
Dima Zavinfce7a472011-04-19 22:30:36 -07002793extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002794audio_module_handle_t aps_load_hw_module(void *service __unused,
2795 const char *name);
2796audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002797 audio_devices_t *pDevices,
2798 uint32_t *pSamplingRate,
2799 audio_format_t *pFormat,
2800 audio_channel_mask_t *pChannelMask,
2801 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002802 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002803
Eric Laurent2d388ec2014-03-07 13:25:54 -08002804audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002805 audio_module_handle_t module,
2806 audio_devices_t *pDevices,
2807 uint32_t *pSamplingRate,
2808 audio_format_t *pFormat,
2809 audio_channel_mask_t *pChannelMask,
2810 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002811 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002812 const audio_offload_info_t *offloadInfo);
2813audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002814 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002815 audio_io_handle_t output2);
2816int aps_close_output(void *service __unused, audio_io_handle_t output);
2817int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2818int aps_restore_output(void *service __unused, audio_io_handle_t output);
2819audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002820 audio_devices_t *pDevices,
2821 uint32_t *pSamplingRate,
2822 audio_format_t *pFormat,
2823 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002824 audio_in_acoustics_t acoustics __unused);
2825audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002826 audio_module_handle_t module,
2827 audio_devices_t *pDevices,
2828 uint32_t *pSamplingRate,
2829 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002830 audio_channel_mask_t *pChannelMask);
2831int aps_close_input(void *service __unused, audio_io_handle_t input);
2832int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002833int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002834 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002835 audio_io_handle_t dst_output);
2836char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2837 const char *keys);
2838void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2839 const char *kv_pairs, int delay_ms);
2840int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002841 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002842 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002843int aps_set_voice_volume(void *service, float volume, int delay_ms);
2844};
Dima Zavinfce7a472011-04-19 22:30:36 -07002845
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002846} // namespace android