blob: dfdd3514c4ffc918a71209f4e2f9cface81cba1a [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 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700275 if (mSpatializer == nullptr) {
276 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
277 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
278 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
279 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200280 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200281 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700282}
283
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530284void AudioPolicyService::unloadAudioPolicyManager()
285{
286 ALOGV("%s ", __func__);
287 if (mLibraryHandle != nullptr) {
288 dlclose(mLibraryHandle);
289 }
290 mLibraryHandle = nullptr;
291 mCreateAudioPolicyManager = nullptr;
292 mDestroyAudioPolicyManager = nullptr;
293}
294
Mathias Agopian65ab4712010-07-14 17:59:35 -0700295AudioPolicyService::~AudioPolicyService()
296{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700297 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700298 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700299
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530300 mDestroyAudioPolicyManager(mAudioPolicyManager);
301 unloadAudioPolicyManager();
302
Eric Laurentdce54a12014-03-10 12:19:46 -0700303 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700304
305 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800306 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800307
308 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800309 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000310
311 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800312 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700313}
314
315// A notification client is always registered by AudioSystem when the client process
316// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800317Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700318{
Eric Laurent12590252015-08-21 18:40:20 -0700319 if (client == 0) {
320 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800321 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700322 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800323 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700324
325 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800326 pid_t pid = IPCThreadState::self()->getCallingPid();
327 int64_t token = ((int64_t)uid<<32) | pid;
328
329 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700330 sp<NotificationClient> notificationClient = new NotificationClient(this,
331 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800332 uid,
333 pid);
334 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700335
luochaojiang908c7d72018-06-21 14:58:04 +0800336 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700337
Marco Nelissenf8880202014-11-14 07:58:25 -0800338 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700339 binder->linkToDeath(notificationClient);
340 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800341 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700342}
343
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800344Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700345{
346 Mutex::Autolock _l(mNotificationClientsLock);
347
348 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800349 pid_t pid = IPCThreadState::self()->getCallingPid();
350 int64_t token = ((int64_t)uid<<32) | pid;
351
352 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800353 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700354 }
luochaojiang908c7d72018-06-21 14:58:04 +0800355 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800356 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700357}
358
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800359Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100360{
361 Mutex::Autolock _l(mNotificationClientsLock);
362
363 uid_t uid = IPCThreadState::self()->getCallingUid();
364 pid_t pid = IPCThreadState::self()->getCallingPid();
365 int64_t token = ((int64_t)uid<<32) | pid;
366
367 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800368 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100369 }
370 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800371 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100372}
373
Eric Laurentb52c1522014-05-20 11:27:36 -0700374// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800375void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700376{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000377 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800378 {
379 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800380 int64_t token = ((int64_t)uid<<32) | pid;
381 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800382 for (size_t i = 0; i < mNotificationClients.size(); i++) {
383 if (mNotificationClients.valueAt(i)->uid() == uid) {
384 hasSameUid = true;
385 break;
386 }
387 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000388 }
389 {
390 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800391 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700392 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700393 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700394 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800395 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700396}
397
398void AudioPolicyService::onAudioPortListUpdate()
399{
400 mOutputCommandThread->updateAudioPortListCommand();
401}
402
403void AudioPolicyService::doOnAudioPortListUpdate()
404{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800405 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700406 for (size_t i = 0; i < mNotificationClients.size(); i++) {
407 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
408 }
409}
410
411void AudioPolicyService::onAudioPatchListUpdate()
412{
413 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700414}
415
Eric Laurentb52c1522014-05-20 11:27:36 -0700416void AudioPolicyService::doOnAudioPatchListUpdate()
417{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800418 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700419 for (size_t i = 0; i < mNotificationClients.size(); i++) {
420 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
421 }
422}
423
François Gaffiecfe17322018-11-07 13:41:29 +0100424void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
425{
426 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
427}
428
429void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
430{
431 Mutex::Autolock _l(mNotificationClientsLock);
432 for (size_t i = 0; i < mNotificationClients.size(); i++) {
433 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
434 }
435}
436
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700437void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700438{
439 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
440 regId.string(), state);
441 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
442}
443
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700444void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700445{
446 Mutex::Autolock _l(mNotificationClientsLock);
447 for (size_t i = 0; i < mNotificationClients.size(); i++) {
448 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
449 }
450}
451
Eric Laurenta9f86652018-11-28 17:23:11 -0800452void AudioPolicyService::onRecordingConfigurationUpdate(
453 int event,
454 const record_client_info_t *clientInfo,
455 const audio_config_base_t *clientConfig,
456 std::vector<effect_descriptor_t> clientEffects,
457 const audio_config_base_t *deviceConfig,
458 std::vector<effect_descriptor_t> effects,
459 audio_patch_handle_t patchHandle,
460 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800461{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800462 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800463 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800464}
465
Eric Laurenta9f86652018-11-28 17:23:11 -0800466void AudioPolicyService::doOnRecordingConfigurationUpdate(
467 int event,
468 const record_client_info_t *clientInfo,
469 const audio_config_base_t *clientConfig,
470 std::vector<effect_descriptor_t> clientEffects,
471 const audio_config_base_t *deviceConfig,
472 std::vector<effect_descriptor_t> effects,
473 audio_patch_handle_t patchHandle,
474 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800475{
476 Mutex::Autolock _l(mNotificationClientsLock);
477 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800478 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800479 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800480 }
481}
482
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700483void AudioPolicyService::onRoutingUpdated()
484{
485 mOutputCommandThread->routingChangedCommand();
486}
487
488void AudioPolicyService::doOnRoutingUpdated()
489{
490 Mutex::Autolock _l(mNotificationClientsLock);
491 for (size_t i = 0; i < mNotificationClients.size(); i++) {
492 mNotificationClients.valueAt(i)->onRoutingUpdated();
493 }
494}
495
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000496void AudioPolicyService::onVolumeRangeInitRequest()
497{
498 mOutputCommandThread->volRangeInitReqCommand();
499}
500
501void AudioPolicyService::doOnVolumeRangeInitRequest()
502{
503 Mutex::Autolock _l(mNotificationClientsLock);
504 for (size_t i = 0; i < mNotificationClients.size(); i++) {
505 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
506 }
507}
508
Eric Laurent81dd0f52021-07-05 11:54:40 +0200509void AudioPolicyService::onCheckSpatializer()
510{
511 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200512 onCheckSpatializer_l();
513}
514
515void AudioPolicyService::onCheckSpatializer_l()
516{
517 if (mSpatializer != nullptr) {
518 mOutputCommandThread->checkSpatializerCommand();
519 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200520}
521
522void AudioPolicyService::doOnCheckSpatializer()
523{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200524 ALOGV("%s mSpatializer %p level %d",
525 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200526
Eric Laurent39095982021-08-24 18:29:27 +0200527 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200528 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200529 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
530 audio_io_handle_t currentOutput = mSpatializer->getOutput();
531 audio_io_handle_t newOutput;
532 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
533 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200534
535 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200536 status_t status =
537 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100538 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
539 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200540 if (status == NO_ERROR && currentOutput == newOutput) {
541 return;
542 }
Eric Laurent15903592022-02-24 20:44:36 +0100543 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200544 mLock.unlock();
545 // It is OK to call detachOutput() is none is already attached.
546 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200547 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
548 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200549 }
Eric Laurent39095982021-08-24 18:29:27 +0200550 mLock.lock();
551 if (status != NO_ERROR) {
552 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
553 }
554 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
555 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200556 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200557
Eric Laurent39095982021-08-24 18:29:27 +0200558 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200559 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200560 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200561 }
562 }
563 }
564}
565
Eric Laurent11094172022-04-05 18:27:42 +0200566size_t AudioPolicyService::countActiveClientsOnOutput_l(
567 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100568 size_t count = 0;
569 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
570 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200571 if (client->io == output && client->active
572 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100573 count++;
574 }
575 }
576 return count;
577}
578
579void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
580 if (mSpatializer == nullptr) {
581 return;
582 }
583 mOutputCommandThread->updateActiveSpatializerTracksCommand();
584}
585
586void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
587{
Eric Laurent21270b62022-07-04 15:11:29 +0200588 if (mSpatializer == nullptr) {
589 return;
590 }
591 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200592 size_t activeClients;
593 {
594 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200595 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100596 }
Eric Laurent21270b62022-07-04 15:11:29 +0200597 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100598}
599
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800600status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
601 audio_patch_handle_t *handle,
602 int delayMs)
603{
604 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
605}
606
607status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
608 int delayMs)
609{
610 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
611}
612
Eric Laurente1715a42014-05-20 11:30:42 -0700613status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
614 int delayMs)
615{
616 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
617}
618
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800619AudioPolicyService::NotificationClient::NotificationClient(
620 const sp<AudioPolicyService>& service,
621 const sp<media::IAudioPolicyServiceClient>& client,
622 uid_t uid,
623 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800624 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100625 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700626{
627}
628
629AudioPolicyService::NotificationClient::~NotificationClient()
630{
631}
632
633void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
634{
635 sp<NotificationClient> keep(this);
636 sp<AudioPolicyService> service = mService.promote();
637 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800638 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700639 }
640}
641
642void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
643{
Eric Laurente8726fe2015-06-26 09:39:24 -0700644 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700645 mAudioPolicyServiceClient->onAudioPortListUpdate();
646 }
647}
648
649void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
650{
Eric Laurente8726fe2015-06-26 09:39:24 -0700651 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700652 mAudioPolicyServiceClient->onAudioPatchListUpdate();
653 }
654}
Eric Laurent57dae992011-07-24 13:36:09 -0700655
Pattydd807582021-11-04 21:01:03 +0800656void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100657 int flags)
658{
659 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
660 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
661 }
662}
663
664
Jean-Michel Trivide801052015-04-14 19:10:14 -0700665void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700666 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700667{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700668 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800669 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
670 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800671 }
672}
673
674void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800675 int event,
676 const record_client_info_t *clientInfo,
677 const audio_config_base_t *clientConfig,
678 std::vector<effect_descriptor_t> clientEffects,
679 const audio_config_base_t *deviceConfig,
680 std::vector<effect_descriptor_t> effects,
681 audio_patch_handle_t patchHandle,
682 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800683{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700684 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800685 status_t status = [&]() -> status_t {
686 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
687 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
688 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700689 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700690 legacy2aidl_audio_config_base_t_AudioConfigBase(
691 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800692 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
693 convertContainer<std::vector<media::EffectDescriptor>>(
694 clientEffects,
695 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700696 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700697 legacy2aidl_audio_config_base_t_AudioConfigBase(
698 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800699 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
700 convertContainer<std::vector<media::EffectDescriptor>>(
701 effects,
702 legacy2aidl_effect_descriptor_t_EffectDescriptor));
703 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
704 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700705 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
706 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800707 return aidl_utils::statusTFromBinderStatus(
708 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
709 clientInfoAidl,
710 clientConfigAidl,
711 clientEffectsAidl,
712 deviceConfigAidl,
713 effectsAidl,
714 patchHandleAidl,
715 sourceAidl));
716 }();
717 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700718 }
719}
720
Eric Laurente8726fe2015-06-26 09:39:24 -0700721void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
722{
723 mAudioPortCallbacksEnabled = enabled;
724}
725
François Gaffiecfe17322018-11-07 13:41:29 +0100726void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
727{
728 mAudioVolumeGroupCallbacksEnabled = enabled;
729}
Eric Laurente8726fe2015-06-26 09:39:24 -0700730
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700731void AudioPolicyService::NotificationClient::onRoutingUpdated()
732{
733 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
734 mAudioPolicyServiceClient->onRoutingUpdated();
735 }
736}
737
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000738void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
739{
740 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
741 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
742 }
743}
744
Mathias Agopian65ab4712010-07-14 17:59:35 -0700745void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700746 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700747 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700748}
749
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000750static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700751{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000752 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
753}
754
755static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
756{
757 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700758}
759
760status_t AudioPolicyService::dumpInternals(int fd)
761{
762 const size_t SIZE = 256;
763 char buffer[SIZE];
764 String8 result;
765
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000766 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800767 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000768 std::stringstream msg;
769 size_t i = 0;
770 for (auto usage : mSupportedSystemUsages) {
771 if (i++ != 0) msg << ", ";
772 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
773 msg << strUsage;
774 } else {
775 msg << usage << " (unknown)";
776 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800777 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000778 if (i == 0) {
779 msg << "None";
780 }
781 msg << std::endl;
782 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800783
Mathias Agopian65ab4712010-07-14 17:59:35 -0700784 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800785
786 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700787 return NO_ERROR;
788}
789
Eric Laurente8c8b432018-10-17 10:08:02 -0700790void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800791{
Eric Laurente8c8b432018-10-17 10:08:02 -0700792 Mutex::Autolock _l(mLock);
793 updateUidStates_l();
794}
795
796void AudioPolicyService::updateUidStates_l()
797{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800798// Go over all active clients and allow capture (does not force silence) in the
799// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800800// The client is in the active assistant list
801// AND is TOP
802// AND an accessibility service is TOP
803// AND source is either VOICE_RECOGNITION OR HOTWORD
804// OR there is no active privacy sensitive capture or call
805// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
806// AND source is VOICE_RECOGNITION OR HOTWORD
807// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800808// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700809// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800810// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800811// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800812// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
813// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800814// OR The client is an accessibility service
815// AND Is on TOP
816// AND the source is VOICE_RECOGNITION or HOTWORD
817// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700818// AND there is no active privacy sensitive capture or call
819// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800820// AND is on TOP
821// AND the source is VOICE_RECOGNITION or HOTWORD
822// OR the client source is virtual (remote submix, call audio TX or RX...)
823// OR the client source is HOTWORD
824// AND is on TOP
825// OR all active clients are using HOTWORD source
826// AND no call is active
827// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
828// OR the client is the current InputMethodService
829// AND a RTT call is active AND the source is VOICE_RECOGNITION
830// OR Any client
831// AND The assistant is not on TOP
832// AND is on TOP or latest started
833// AND there is no active privacy sensitive capture or call
834// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800835
Eric Laurent4e947da2019-10-17 15:24:06 -0700836
Eric Laurent4eb58f12018-12-07 16:41:02 -0800837 sp<AudioRecordClient> topActive;
838 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800839 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700840 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800841 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700842
Eric Laurenta46bedb2018-12-07 18:01:26 -0800843 nsecs_t topStartNs = 0;
844 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800845 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800846 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800847 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800848 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
849 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800850 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800851 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700852 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800853 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
854 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700855 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700856 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700857 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800858
Michael Groovercfd28302018-12-11 19:16:46 -0800859 // if Sensor Privacy is enabled then all recordings should be silenced.
860 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
861 silenceAllRecordings_l();
862 return;
863 }
864
Eric Laurente8c8b432018-10-17 10:08:02 -0700865 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
866 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000867 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
868 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800869 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700870 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800871 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700872
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700873 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700874 // clients which app is in IDLE state are not eligible for top active or
875 // latest active
876 if (appState == APP_STATE_IDLE) {
877 continue;
878 }
879
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700880 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700881 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800882 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700883 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700884 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800885 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800886 bool isPrivacySensitive =
887 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700888
Eric Laurentc21d5692020-02-25 10:24:36 -0800889 if (appState == APP_STATE_TOP) {
890 if (isPrivacySensitive) {
891 if (current->startTimeNs > topSensitiveStartNs) {
892 topSensitiveActive = current;
893 topSensitiveStartNs = current->startTimeNs;
894 }
895 } else {
896 if (current->startTimeNs > topStartNs) {
897 topActive = current;
898 topStartNs = current->startTimeNs;
899 }
900 }
901 if (isAssistant) {
902 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800903 if (isActiveAssistant) {
904 useActiveAssistantList = true;
905 } else if (!useActiveAssistantList) {
906 if (current->startTimeNs > latestAssistantStartNs) {
907 latestActiveAssistant = current;
908 latestAssistantStartNs = current->startTimeNs;
909 }
910 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800911 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800912 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800913 // Clients capturing for HOTWORD are not considered
914 // for latest active to avoid masking regular clients started before
915 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
916 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
917 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700918 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
919 // is marked latest sensitive active even if another app qualifies.
920 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700921 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700922 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700923 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000924 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700925 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700926 latestSensitiveActiveOrComm = current;
927 latestSensitiveStartNs = current->startTimeNs;
928 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800929 }
930 isSensitiveActive = true;
931 } else {
932 if (current->startTimeNs > latestStartNs) {
933 latestActive = current;
934 latestStartNs = current->startTimeNs;
935 }
936 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800937 }
938 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700939 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
940 onlyHotwordActive = false;
941 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100942 if (currentUid == mPhoneStateOwnerUid &&
943 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700944 isPhoneStateOwnerActive = true;
945 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800946 }
947
Eric Laurent1ff16a72019-03-14 18:35:04 -0700948 // if no active client with UI on Top, consider latest active as top
949 if (topActive == nullptr) {
950 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800951 topStartNs = latestStartNs;
952 }
953 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700954 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800955 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700956 } else if (latestSensitiveActiveOrComm != nullptr) {
957 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
958 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700959 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000960 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700961 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700962 topSensitiveActive = latestSensitiveActiveOrComm;
963 topSensitiveStartNs = latestSensitiveStartNs;
964 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800965 }
966
967 // If both privacy sensitive and regular capture are active:
968 // if the regular capture is privileged
969 // allow concurrency
970 // else
971 // favor the privacy sensitive case
972 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700973 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800974 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800975 }
976
977 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
978 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700979 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000980 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700981 if (!current->active) {
982 continue;
983 }
984
Eric Laurent4eb58f12018-12-07 16:41:02 -0800985 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700986 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000987 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700988 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000989 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800990 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
991 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -0800992
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000993 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700994 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000995 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -0700996 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -0700997 bool canCaptureCommunication = recordClient->canCaptureOutput
998 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700999 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001000 return !(isInCall && !canCaptureCall)
1001 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001002 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001003
1004 // By default allow capture if:
1005 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001006 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001007 // AND there is no active privacy sensitive capture or call
1008 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1009 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001010 && (isTopOrLatestActive || isTopOrLatestSensitive)
1011 && !(isSensitiveActive
Ricardo Correa57a37692020-03-23 17:27:25 -07001012 && !(isTopOrLatestSensitive || current->canCaptureOutput))
Eric Laurentc21d5692020-02-25 10:24:36 -08001013 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001014
Eric Laurented726cc2021-07-01 14:26:41 +02001015 if (!current->hasOp()) {
1016 // Never allow capture if app op is denied
1017 allowCapture = false;
1018 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001019 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1020 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001021 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001022 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001023 // Active assistant list is not being used
1024 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001025 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001026 // OR there is no active privacy sensitive capture or call
1027 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1028 // AND is latest TOP assistant AND
1029 // uses VOICE_RECOGNITION OR uses HOTWORD
1030 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001031 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001032 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001033 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001034 }
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001035 } else if (!(isSensitiveActive && !current->canCaptureOutput)
1036 && canCaptureIfInCallOrCommunication(current)) {
1037 if (isTopOrLatestAssistant
1038 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1039 || source == AUDIO_SOURCE_HOTWORD)) {
1040 allowCapture = true;
1041 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1042 allowCapture = true;
1043 }
1044 }
1045 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1046 // For assistant on active list and on top allow capture if:
1047 // An accessibility service is on TOP
1048 // AND the source is VOICE_RECOGNITION or HOTWORD
1049 // OR there is no active privacy sensitive capture or call
1050 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1051 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1052 if (isA11yOnTop) {
1053 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1054 allowCapture = true;
1055 }
1056 } else if (!(isSensitiveActive && !current->canCaptureOutput)
Eric Laurentc21d5692020-02-25 10:24:36 -08001057 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001058 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1059 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001060 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001061 }
1062 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001063 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001064 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001065 // The assistant is not on TOP
1066 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001067 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001068 // OR
1069 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1070 if (!isAssistantOnTop
Ricardo Correa57a37692020-03-23 17:27:25 -07001071 && !(isSensitiveActive && !current->canCaptureOutput)
Eric Laurentc21d5692020-02-25 10:24:36 -08001072 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001073 allowCapture = true;
1074 }
Eric Laurent589171c2019-07-25 18:04:29 -07001075 if (isA11yOnTop) {
1076 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1077 allowCapture = true;
1078 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001079 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001080 } else if (source == AUDIO_SOURCE_HOTWORD) {
1081 // For HOTWORD source allow capture when not on TOP if:
1082 // All active clients are using HOTWORD source
1083 // AND no call is active
1084 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001085 if (onlyHotwordActive
1086 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001087 allowCapture = true;
1088 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001089 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001090 // For current InputMethodService allow capture if:
1091 // A RTT call is active AND the source is VOICE_RECOGNITION
1092 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1093 allowCapture = true;
1094 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001095 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001096 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001097 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001098 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001099 }
1100}
1101
Michael Groovercfd28302018-12-11 19:16:46 -08001102void AudioPolicyService::silenceAllRecordings_l() {
1103 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1104 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001105 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001106 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001107 }
Michael Groovercfd28302018-12-11 19:16:46 -08001108 }
1109}
1110
Eric Laurente8c8b432018-10-17 10:08:02 -07001111/* static */
1112app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001113
1114 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001115 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001116 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1117 // include persistent services
1118 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001119 }
1120 return APP_STATE_FOREGROUND;
1121}
1122
Eric Laurent4eb58f12018-12-07 16:41:02 -08001123/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001124bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001125{
1126 switch (source) {
1127 case AUDIO_SOURCE_VOICE_UPLINK:
1128 case AUDIO_SOURCE_VOICE_DOWNLINK:
1129 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001130 case AUDIO_SOURCE_REMOTE_SUBMIX:
1131 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001132 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001133 return true;
1134 default:
1135 break;
1136 }
1137 return false;
1138}
1139
Eric Laurented726cc2021-07-01 14:26:41 +02001140/* static */
1141bool AudioPolicyService::isAppOpSource(audio_source_t source)
1142{
1143 switch (source) {
1144 case AUDIO_SOURCE_FM_TUNER:
1145 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001146 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001147 return false;
1148 default:
1149 break;
1150 }
1151 return true;
1152}
1153
Eric Laurent8c7ef892021-06-10 13:32:16 +02001154void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001155{
1156 AutoCallerClear acc;
1157
1158 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001159 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001160 }
1161 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1162 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001163 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001164 if (client->silenced != silenced) {
1165 if (client->active) {
1166 if (silenced) {
1167 finishRecording(client->attributionSource, client->attributes.source);
1168 } else {
1169 std::stringstream msg;
1170 msg << "Audio recording un-silenced on session " << client->session;
1171 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1172 client->attributes.source)) {
1173 silenced = true;
1174 }
1175 }
1176 }
1177 af->setRecordSilenced(client->portId, silenced);
1178 client->silenced = silenced;
1179 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001180 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001181}
1182
Glenn Kasten0f11b512014-01-31 16:18:54 -08001183status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001184{
Glenn Kasten44deb052012-02-05 18:09:08 -08001185 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001186 dumpPermissionDenial(fd);
1187 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001188 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001189 if (!locked) {
1190 String8 result(kDeadlockedString);
1191 write(fd, result.string(), result.size());
1192 }
1193
1194 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001195
1196 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1197 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001198 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001199 mAudioCommandThread->dump(fd);
1200 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001201
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001202 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1203 write(fd, octPtr.string(), octPtr.size());
1204 if (mOutputCommandThread != 0) {
1205 mOutputCommandThread->dump(fd);
1206 }
1207
Eric Laurentdce54a12014-03-10 12:19:46 -07001208 if (mAudioPolicyManager) {
1209 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001210 } else {
1211 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1212 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001213 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001214
Kevin Rocard8be94972019-02-22 13:26:25 -08001215 mPackageManager.dump(fd);
1216
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001217 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001218
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001219 if (mSpatializer != nullptr) {
1220 std::string dumpString = mSpatializer->toString(1 /* level */);
1221 write(fd, dumpString.c_str(), dumpString.size());
1222 } else {
1223 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1224 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1225 }
1226
Andy Hungc747c532022-03-07 21:41:14 -08001227 {
1228 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1229 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1230 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1231 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001232 }
1233 return NO_ERROR;
1234}
1235
1236status_t AudioPolicyService::dumpPermissionDenial(int fd)
1237{
1238 const size_t SIZE = 256;
1239 char buffer[SIZE];
1240 String8 result;
1241 snprintf(buffer, SIZE, "Permission Denial: "
1242 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1243 IPCThreadState::self()->getCallingPid(),
1244 IPCThreadState::self()->getCallingUid());
1245 result.append(buffer);
1246 write(fd, result.string(), result.size());
1247 return NO_ERROR;
1248}
1249
1250status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001251 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001252 // make sure transactions reserved to AudioFlinger do not come from other processes
1253 switch (code) {
1254 case TRANSACTION_startOutput:
1255 case TRANSACTION_stopOutput:
1256 case TRANSACTION_releaseOutput:
1257 case TRANSACTION_getInputForAttr:
1258 case TRANSACTION_startInput:
1259 case TRANSACTION_stopInput:
1260 case TRANSACTION_releaseInput:
1261 case TRANSACTION_getOutputForEffect:
1262 case TRANSACTION_registerEffect:
1263 case TRANSACTION_unregisterEffect:
1264 case TRANSACTION_setEffectEnabled:
1265 case TRANSACTION_getStrategyForStream:
1266 case TRANSACTION_getOutputForAttr:
1267 case TRANSACTION_moveEffectsToIo:
1268 ALOGW("%s: transaction %d received from PID %d",
1269 __func__, code, IPCThreadState::self()->getCallingPid());
1270 return INVALID_OPERATION;
1271 default:
1272 break;
1273 }
1274
1275 // make sure the following transactions come from system components
1276 switch (code) {
1277 case TRANSACTION_setDeviceConnectionState:
1278 case TRANSACTION_handleDeviceConfigChange:
1279 case TRANSACTION_setPhoneState:
1280//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1281// case TRANSACTION_setForceUse:
1282 case TRANSACTION_initStreamVolume:
1283 case TRANSACTION_setStreamVolumeIndex:
1284 case TRANSACTION_setVolumeIndexForAttributes:
1285 case TRANSACTION_getStreamVolumeIndex:
1286 case TRANSACTION_getVolumeIndexForAttributes:
1287 case TRANSACTION_getMinVolumeIndexForAttributes:
1288 case TRANSACTION_getMaxVolumeIndexForAttributes:
1289 case TRANSACTION_isStreamActive:
1290 case TRANSACTION_isStreamActiveRemotely:
1291 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001292 case TRANSACTION_registerPolicyMixes:
1293 case TRANSACTION_setMasterMono:
1294 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001295 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001296 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001297 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001298 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001299 case TRANSACTION_setA11yServicesUids:
1300 case TRANSACTION_setUidDeviceAffinities:
1301 case TRANSACTION_removeUidDeviceAffinities:
1302 case TRANSACTION_setUserIdDeviceAffinities:
1303 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001304 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001305 case TRANSACTION_listAudioVolumeGroups:
1306 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1307 case TRANSACTION_acquireSoundTriggerSession:
1308 case TRANSACTION_releaseSoundTriggerSession:
1309 case TRANSACTION_setRttEnabled:
1310 case TRANSACTION_isCallScreenModeSupported:
1311 case TRANSACTION_setDevicesRoleForStrategy:
1312 case TRANSACTION_setSupportedSystemUsages:
1313 case TRANSACTION_removeDevicesRoleForStrategy:
1314 case TRANSACTION_getDevicesForRoleAndStrategy:
1315 case TRANSACTION_getDevicesForAttributes:
1316 case TRANSACTION_setAllowedCapturePolicy:
1317 case TRANSACTION_onNewAudioModulesAvailable:
1318 case TRANSACTION_setCurrentImeUid:
1319 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1320 case TRANSACTION_setDevicesRoleForCapturePreset:
1321 case TRANSACTION_addDevicesRoleForCapturePreset:
1322 case TRANSACTION_removeDevicesRoleForCapturePreset:
1323 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001324 case TRANSACTION_getDevicesForRoleAndCapturePreset:
1325 case TRANSACTION_getSpatializer: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001326 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1327 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1328 __func__, code, IPCThreadState::self()->getCallingPid(),
1329 IPCThreadState::self()->getCallingUid());
1330 return INVALID_OPERATION;
1331 }
1332 } break;
1333 default:
1334 break;
1335 }
1336
Andy Hungc747c532022-03-07 21:41:14 -08001337 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1338 mediautils::TimeCheck check(
1339 std::string("IAudioPolicyService::").append(methodName),
1340 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1341 if (timeout) {
1342 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1343 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1344 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1345 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1346 .record();
1347 } else {
1348 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1349 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001350 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1351 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1352 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001353
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001354 switch (code) {
1355 case SHELL_COMMAND_TRANSACTION: {
1356 int in = data.readFileDescriptor();
1357 int out = data.readFileDescriptor();
1358 int err = data.readFileDescriptor();
1359 int argc = data.readInt32();
1360 Vector<String16> args;
1361 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1362 args.add(data.readString16());
1363 }
1364 sp<IBinder> unusedCallback;
1365 sp<IResultReceiver> resultReceiver;
1366 status_t status;
1367 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1368 return status;
1369 }
1370 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1371 return status;
1372 }
1373 status = shellCommand(in, out, err, args);
1374 if (resultReceiver != nullptr) {
1375 resultReceiver->send(status);
1376 }
1377 return NO_ERROR;
1378 }
1379 }
1380
Mathias Agopian65ab4712010-07-14 17:59:35 -07001381 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1382}
1383
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001384// ------------------- Shell command implementation -------------------
1385
1386// NOTE: This is a remote API - make sure all args are validated
1387status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1388 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1389 return PERMISSION_DENIED;
1390 }
1391 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1392 return BAD_VALUE;
1393 }
jovanakbe066e12019-09-02 11:54:39 -07001394 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001395 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001396 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001397 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001398 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001399 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001400 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1401 purgePermissionCache();
1402 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001403 } else if (args.size() == 1 && args[0] == String16("help")) {
1404 printHelp(out);
1405 return NO_ERROR;
1406 }
1407 printHelp(err);
1408 return BAD_VALUE;
1409}
1410
jovanakbe066e12019-09-02 11:54:39 -07001411static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1412 if (userId < 0) {
1413 ALOGE("Invalid user: %d", userId);
1414 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001415 return BAD_VALUE;
1416 }
jovanakbe066e12019-09-02 11:54:39 -07001417
1418 PermissionController pc;
1419 uid = pc.getPackageUid(packageName, 0);
1420 if (uid <= 0) {
1421 ALOGE("Unknown package: '%s'", String8(packageName).string());
1422 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1423 return BAD_VALUE;
1424 }
1425
1426 uid = multiuser_get_uid(userId, uid);
1427 return NO_ERROR;
1428}
1429
1430status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1431 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1432 if (!(args.size() == 3 || args.size() == 5)) {
1433 printHelp(err);
1434 return BAD_VALUE;
1435 }
1436
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001437 bool active = false;
1438 if (args[2] == String16("active")) {
1439 active = true;
1440 } else if ((args[2] != String16("idle"))) {
1441 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1442 return BAD_VALUE;
1443 }
jovanakbe066e12019-09-02 11:54:39 -07001444
1445 int userId = 0;
1446 if (args.size() >= 5 && args[3] == String16("--user")) {
1447 userId = atoi(String8(args[4]));
1448 }
1449
1450 uid_t uid;
1451 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1452 return BAD_VALUE;
1453 }
1454
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001455 sp<UidPolicy> uidPolicy;
1456 {
1457 Mutex::Autolock _l(mLock);
1458 uidPolicy = mUidPolicy;
1459 }
1460 if (uidPolicy) {
1461 uidPolicy->addOverrideUid(uid, active);
1462 return NO_ERROR;
1463 }
1464 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001465}
1466
1467status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001468 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1469 if (!(args.size() == 2 || args.size() == 4)) {
1470 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001471 return BAD_VALUE;
1472 }
jovanakbe066e12019-09-02 11:54:39 -07001473
1474 int userId = 0;
1475 if (args.size() >= 4 && args[2] == String16("--user")) {
1476 userId = atoi(String8(args[3]));
1477 }
1478
1479 uid_t uid;
1480 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1481 return BAD_VALUE;
1482 }
1483
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001484 sp<UidPolicy> uidPolicy;
1485 {
1486 Mutex::Autolock _l(mLock);
1487 uidPolicy = mUidPolicy;
1488 }
1489 if (uidPolicy) {
1490 uidPolicy->removeOverrideUid(uid);
1491 return NO_ERROR;
1492 }
1493 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001494}
1495
1496status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001497 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1498 if (!(args.size() == 2 || args.size() == 4)) {
1499 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001500 return BAD_VALUE;
1501 }
jovanakbe066e12019-09-02 11:54:39 -07001502
1503 int userId = 0;
1504 if (args.size() >= 4 && args[2] == String16("--user")) {
1505 userId = atoi(String8(args[3]));
1506 }
1507
1508 uid_t uid;
1509 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1510 return BAD_VALUE;
1511 }
1512
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001513 sp<UidPolicy> uidPolicy;
1514 {
1515 Mutex::Autolock _l(mLock);
1516 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001517 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001518 if (uidPolicy) {
1519 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1520 }
1521 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001522}
1523
1524status_t AudioPolicyService::printHelp(int out) {
1525 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001526 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1527 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1528 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001529 " help print this message\n");
1530}
1531
1532// ----------- AudioPolicyService::UidPolicy implementation ----------
1533
1534void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001535 status_t res = mAm.linkToDeath(this);
1536 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001537 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001538 | ActivityManager::UID_OBSERVER_ACTIVE
1539 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001540 ActivityManager::PROCESS_STATE_UNKNOWN,
1541 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001542 if (!res) {
1543 Mutex::Autolock _l(mLock);
1544 mObserverRegistered = true;
1545 } else {
1546 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001547
Steven Moreland2f348142019-07-02 15:59:07 -07001548 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001549 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001550}
1551
1552void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001553 mAm.unlinkToDeath(this);
1554 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001555 Mutex::Autolock _l(mLock);
1556 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001557}
1558
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001559void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1560 Mutex::Autolock _l(mLock);
1561 mCachedUids.clear();
1562 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001563}
1564
Eric Laurente8c8b432018-10-17 10:08:02 -07001565void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001566 bool needToReregister = false;
1567 {
1568 Mutex::Autolock _l(mLock);
1569 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001570 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001571 if (needToReregister) {
1572 // Looks like ActivityManager has died previously, attempt to re-register.
1573 registerSelf();
1574 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001575}
1576
1577bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1578 if (isServiceUid(uid)) return true;
1579 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001580 {
1581 Mutex::Autolock _l(mLock);
1582 auto overrideIter = mOverrideUids.find(uid);
1583 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001584 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001585 }
1586 // In an absense of the ActivityManager, assume everything to be active.
1587 if (!mObserverRegistered) return true;
1588 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001589 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001590 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001591 }
1592 }
1593 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001594 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001595 {
1596 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001597 mCachedUids.insert(std::pair<uid_t,
1598 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1599 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001600 }
1601 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001602}
1603
Eric Laurente8c8b432018-10-17 10:08:02 -07001604int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1605 if (isServiceUid(uid)) {
1606 return ActivityManager::PROCESS_STATE_TOP;
1607 }
1608 checkRegistered();
1609 {
1610 Mutex::Autolock _l(mLock);
1611 auto overrideIter = mOverrideUids.find(uid);
1612 if (overrideIter != mOverrideUids.end()) {
1613 if (overrideIter->second.first) {
1614 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1615 return overrideIter->second.second;
1616 } else {
1617 auto cacheIter = mCachedUids.find(uid);
1618 if (cacheIter != mCachedUids.end()) {
1619 return cacheIter->second.second;
1620 }
1621 }
1622 }
1623 return ActivityManager::PROCESS_STATE_UNKNOWN;
1624 }
1625 // In an absense of the ActivityManager, assume everything to be active.
1626 if (!mObserverRegistered) {
1627 return ActivityManager::PROCESS_STATE_TOP;
1628 }
1629 auto cacheIter = mCachedUids.find(uid);
1630 if (cacheIter != mCachedUids.end()) {
1631 if (cacheIter->second.first) {
1632 return cacheIter->second.second;
1633 } else {
1634 return ActivityManager::PROCESS_STATE_UNKNOWN;
1635 }
1636 }
1637 }
1638 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001639 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001640 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1641 if (active) {
1642 state = am.getUidProcessState(uid, String16("audioserver"));
1643 }
1644 {
1645 Mutex::Autolock _l(mLock);
1646 mCachedUids.insert(std::pair<uid_t,
1647 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1648 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001649
Eric Laurente8c8b432018-10-17 10:08:02 -07001650 return state;
1651}
1652
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001653void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001654 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001655}
1656
1657void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001658 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001659}
1660
1661void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001662 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001663}
1664
Eric Laurente8c8b432018-10-17 10:08:02 -07001665void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1666 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001667 int64_t procStateSeq __unused,
1668 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001669 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1670 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001671 }
1672}
1673
Austin Borger65577682022-02-17 00:25:43 +00001674void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1675}
1676
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001677void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001678 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1679}
1680
1681void AudioPolicyService::UidPolicy::notifyService() {
1682 sp<AudioPolicyService> service = mService.promote();
1683 if (service != nullptr) {
1684 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001685 }
1686}
1687
Eric Laurente8c8b432018-10-17 10:08:02 -07001688void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1689 std::pair<bool, int>> *uids,
1690 uid_t uid,
1691 bool active,
1692 int state,
1693 bool insert) {
1694 if (isServiceUid(uid)) {
1695 return;
1696 }
1697 bool wasActive = isUidActive(uid);
1698 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001699 {
1700 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001701 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001702 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001703 if (wasActive != isUidActive(uid) || state != previousState) {
1704 notifyService();
1705 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001706}
1707
Eric Laurente8c8b432018-10-17 10:08:02 -07001708void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1709 std::pair<bool, int>> *uids,
1710 uid_t uid,
1711 bool active,
1712 int state,
1713 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001714 auto it = uids->find(uid);
1715 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001716 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001717 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1718 it->second.first = active;
1719 }
1720 if (it->second.first) {
1721 it->second.second = state;
1722 } else {
1723 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1724 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001725 } else {
1726 uids->erase(it);
1727 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001728 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1729 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1730 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001731 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001732}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001733
Eric Laurent4eb58f12018-12-07 16:41:02 -08001734bool AudioPolicyService::UidPolicy::isA11yOnTop() {
1735 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001736 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001737 continue;
1738 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001739 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1740 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001741 return true;
1742 }
1743 }
1744 return false;
1745}
1746
Eric Laurentb78763e2018-10-17 10:08:02 -07001747bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1748{
1749 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1750 return it != mA11yUids.end();
1751}
1752
Oscar Azucena829d90d2022-01-28 17:17:56 -08001753void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1754 mAssistantUids.clear();
1755 mAssistantUids = uids;
1756}
1757
1758bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1759{
1760 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1761 return it != mAssistantUids.end();
1762}
1763
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001764void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1765 mActiveAssistantUids = activeUids;
1766}
1767
1768bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1769{
1770 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1771 mActiveAssistantUids.end(), uid);
1772 return it != mActiveAssistantUids.end();
1773}
1774
Oscar Azucena829d90d2022-01-28 17:17:56 -08001775void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1776 const size_t SIZE = 256;
1777 char buffer[SIZE];
1778 String8 result;
1779 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1780 snprintf(buffer, SIZE, "\t%s: \n", title);
1781 result.append(buffer);
1782 int counter = 0;
1783 if (uids.empty()) {
1784 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1785 result.append(buffer);
1786 return;
1787 }
1788 for (const auto &uid : uids) {
1789 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1790 result.append(buffer);
1791 }
1792 };
1793
1794 snprintf(buffer, SIZE, "UID Policy:\n");
1795 result.append(buffer);
1796 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1797 result.append(buffer);
1798
1799 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001800 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001801
1802 appendUidsToResult("Accessibility UIDs", mA11yUids);
1803
1804 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1805 result.append(buffer);
1806
1807 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1808 result.append(buffer);
1809
1810 write(fd, result.string(), result.size());
1811}
1812
Michael Groovercfd28302018-12-11 19:16:46 -08001813// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1814void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1815 SensorPrivacyManager spm;
1816 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1817 spm.addSensorPrivacyListener(this);
1818}
1819
1820void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1821 SensorPrivacyManager spm;
1822 spm.removeSensorPrivacyListener(this);
1823}
1824
1825bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1826 return mSensorPrivacyEnabled;
1827}
1828
Evan Seversond8dc6832022-01-27 10:47:03 -08001829binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1830 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001831 mSensorPrivacyEnabled = enabled;
1832 sp<AudioPolicyService> service = mService.promote();
1833 if (service != nullptr) {
1834 service->updateUidStates();
1835 }
1836 return binder::Status::ok();
1837}
1838
Eric Laurented726cc2021-07-01 14:26:41 +02001839// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1840
1841// static
1842sp<AudioPolicyService::OpRecordAudioMonitor>
1843AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1844 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1845 wp<AudioCommandThread> commandThread)
1846{
Eric Laurent987ce102021-07-05 12:11:51 +02001847 if (isAudioServerOrRootUid(attributionSource.uid)) {
1848 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001849 attributionSource.toString().c_str());
1850 return nullptr;
1851 }
1852
1853 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1854 ALOGD("not monitoring app op for uid %d and source %d",
1855 attributionSource.uid, attr.source);
1856 return nullptr;
1857 }
1858
1859 if (!attributionSource.packageName.has_value()
1860 || attributionSource.packageName.value().size() == 0) {
1861 return nullptr;
1862 }
1863 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1864}
1865
1866AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1867 const AttributionSourceState& attributionSource, int32_t appOp,
1868 wp<AudioCommandThread> commandThread) :
1869 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1870 mCommandThread(commandThread)
1871{
1872}
1873
1874AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1875{
1876 if (mOpCallback != 0) {
1877 mAppOpsManager.stopWatchingMode(mOpCallback);
1878 }
1879 mOpCallback.clear();
1880}
1881
1882void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1883{
1884 checkOp();
1885 mOpCallback = new RecordAudioOpCallback(this);
1886 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1887 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1888 // since it controls the mic permission for legacy apps.
1889 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1890 mAttributionSource.packageName.value_or(""))),
1891 mOpCallback);
1892}
1893
1894bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1895 return mHasOp.load();
1896}
1897
1898// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1899// is updated in AppOp callback and in onFirstRef()
1900// Note this method is never called (and never to be) for audio server / root track
1901// due to the UID in createIfNeeded(). As a result for those record track, it's:
1902// - not called from constructor,
1903// - not called from RecordAudioOpCallback because the callback is not installed in this case
1904void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1905{
1906 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1907 // since it controls the mic permission for legacy apps.
1908 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1909 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1910 mAttributionSource.packageName.value_or(""))));
1911 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1912 // verbose logging only log when appOp changed
1913 ALOGI_IF(hasIt != mHasOp.load(),
1914 "App op %d missing, %ssilencing record %s",
1915 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1916 mHasOp.store(hasIt);
1917
1918 if (updateUidStates) {
1919 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1920 if (commandThread != nullptr) {
1921 commandThread->updateUidStatesCommand();
1922 }
1923 }
1924}
1925
1926AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1927 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1928{ }
1929
1930void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1931 const String16& packageName __unused) {
1932 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1933 if (monitor != NULL) {
1934 if (op != monitor->getOp()) {
1935 return;
1936 }
1937 monitor->checkOp(true);
1938 }
1939}
1940
1941
Mathias Agopian65ab4712010-07-14 17:59:35 -07001942// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1943
Eric Laurentbfb1b832013-01-07 09:53:42 -08001944AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1945 const wp<AudioPolicyService>& service)
1946 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001947{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001948}
1949
1950
1951AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1952{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001953 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001954 release_wake_lock(mName.string());
1955 }
1956 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001957}
1958
1959void AudioPolicyService::AudioCommandThread::onFirstRef()
1960{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001961 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001962}
1963
1964bool AudioPolicyService::AudioCommandThread::threadLoop()
1965{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001966 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001967
1968 mLock.lock();
1969 while (!exitPending())
1970 {
Eric Laurent59a89232014-06-08 14:14:17 -07001971 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001972 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001973 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001974 nsecs_t curTime = systemTime();
1975 // commands are sorted by increasing time stamp: execute them from index 0 and up
1976 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001977 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001978 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001979 if (mAudioCommands.isEmpty()) {
1980 ++numTimesBecameEmpty;
1981 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001982 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001983
1984 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001985 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001986 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001987 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001988 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001989 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001990 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1991 data->mVolume,
1992 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001993 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001994 }break;
1995 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001996 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001997 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
1998 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001999 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002000 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002001 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002002 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002003 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002004 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002005 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002006 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002007 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002008 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002009 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002010 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002011 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002012 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002013 ALOGV("AudioCommandThread() processing stop output portId %d",
2014 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002015 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002016 if (svc == 0) {
2017 break;
2018 }
2019 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002020 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002021 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002022 }break;
2023 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002024 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002025 ALOGV("AudioCommandThread() processing release output portId %d",
2026 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002027 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002028 if (svc == 0) {
2029 break;
2030 }
2031 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002032 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002033 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002034 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002035 case CREATE_AUDIO_PATCH: {
2036 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2037 ALOGV("AudioCommandThread() processing create audio patch");
2038 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2039 if (af == 0) {
2040 command->mStatus = PERMISSION_DENIED;
2041 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002042 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002043 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002044 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002045 }
2046 } break;
2047 case RELEASE_AUDIO_PATCH: {
2048 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2049 ALOGV("AudioCommandThread() processing release audio patch");
2050 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2051 if (af == 0) {
2052 command->mStatus = PERMISSION_DENIED;
2053 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002054 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002055 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002056 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002057 }
2058 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002059 case UPDATE_AUDIOPORT_LIST: {
2060 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002061 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002062 if (svc == 0) {
2063 break;
2064 }
2065 mLock.unlock();
2066 svc->doOnAudioPortListUpdate();
2067 mLock.lock();
2068 }break;
2069 case UPDATE_AUDIOPATCH_LIST: {
2070 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002071 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002072 if (svc == 0) {
2073 break;
2074 }
2075 mLock.unlock();
2076 svc->doOnAudioPatchListUpdate();
2077 mLock.lock();
2078 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002079 case CHANGED_AUDIOVOLUMEGROUP: {
2080 AudioVolumeGroupData *data =
2081 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2082 ALOGV("AudioCommandThread() processing update audio volume group");
2083 svc = mService.promote();
2084 if (svc == 0) {
2085 break;
2086 }
2087 mLock.unlock();
2088 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2089 mLock.lock();
2090 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002091 case SET_AUDIOPORT_CONFIG: {
2092 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2093 ALOGV("AudioCommandThread() processing set port config");
2094 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2095 if (af == 0) {
2096 command->mStatus = PERMISSION_DENIED;
2097 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002098 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002099 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002100 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002101 }
2102 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002103 case DYN_POLICY_MIX_STATE_UPDATE: {
2104 DynPolicyMixStateUpdateData *data =
2105 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002106 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2107 data->mRegId.string(), data->mState);
2108 svc = mService.promote();
2109 if (svc == 0) {
2110 break;
2111 }
2112 mLock.unlock();
2113 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2114 mLock.lock();
2115 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002116 case RECORDING_CONFIGURATION_UPDATE: {
2117 RecordingConfigurationUpdateData *data =
2118 (RecordingConfigurationUpdateData *)command->mParam.get();
2119 ALOGV("AudioCommandThread() processing recording configuration update");
2120 svc = mService.promote();
2121 if (svc == 0) {
2122 break;
2123 }
2124 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002125 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002126 &data->mClientConfig, data->mClientEffects,
2127 &data->mDeviceConfig, data->mEffects,
2128 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002129 mLock.lock();
2130 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002131 case SET_EFFECT_SUSPENDED: {
2132 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2133 ALOGV("AudioCommandThread() processing set effect suspended");
2134 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2135 if (af != 0) {
2136 mLock.unlock();
2137 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2138 mLock.lock();
2139 }
2140 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002141 case AUDIO_MODULES_UPDATE: {
2142 ALOGV("AudioCommandThread() processing audio modules update");
2143 svc = mService.promote();
2144 if (svc == 0) {
2145 break;
2146 }
2147 mLock.unlock();
2148 svc->doOnNewAudioModulesAvailable();
2149 mLock.lock();
2150 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002151 case ROUTING_UPDATED: {
2152 ALOGV("AudioCommandThread() processing routing update");
2153 svc = mService.promote();
2154 if (svc == 0) {
2155 break;
2156 }
2157 mLock.unlock();
2158 svc->doOnRoutingUpdated();
2159 mLock.lock();
2160 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002161
Eric Laurented726cc2021-07-01 14:26:41 +02002162 case UPDATE_UID_STATES: {
2163 ALOGV("AudioCommandThread() processing updateUID states");
2164 svc = mService.promote();
2165 if (svc == 0) {
2166 break;
2167 }
2168 mLock.unlock();
2169 svc->updateUidStates();
2170 mLock.lock();
2171 } break;
2172
Eric Laurent15903592022-02-24 20:44:36 +01002173 case CHECK_SPATIALIZER_OUTPUT: {
2174 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002175 svc = mService.promote();
2176 if (svc == 0) {
2177 break;
2178 }
2179 mLock.unlock();
2180 svc->doOnCheckSpatializer();
2181 mLock.lock();
2182 } break;
2183
Eric Laurent15903592022-02-24 20:44:36 +01002184 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2185 ALOGV("AudioCommandThread() processing update spatializer tracks");
2186 svc = mService.promote();
2187 if (svc == 0) {
2188 break;
2189 }
2190 mLock.unlock();
2191 svc->doOnUpdateActiveSpatializerTracks();
2192 mLock.lock();
2193 } break;
2194
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002195 case VOL_RANGE_INIT_REQUEST: {
2196 ALOGV("AudioCommandThread() processing volume range init request");
2197 svc = mService.promote();
2198 if (svc == 0) {
2199 break;
2200 }
2201 mLock.unlock();
2202 svc->doOnVolumeRangeInitRequest();
2203 mLock.lock();
2204 } break;
2205
Mathias Agopian65ab4712010-07-14 17:59:35 -07002206 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002207 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002208 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002209 {
2210 Mutex::Autolock _l(command->mLock);
2211 if (command->mWaitStatus) {
2212 command->mWaitStatus = false;
2213 command->mCond.signal();
2214 }
2215 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002216 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002217 // release mLock before releasing strong reference on the service as
2218 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2219 // acquires mLock.
2220 mLock.unlock();
2221 svc.clear();
2222 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002223 } else {
2224 waitTime = mAudioCommands[0]->mTime - curTime;
2225 break;
2226 }
2227 }
Zach Janga754b4f2015-10-27 01:29:34 +00002228
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002229 // release delayed commands wake lock as many times as we made the queue is
2230 // empty during popping.
2231 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002232 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002233 }
2234
2235 // At this stage we have either an empty command queue or the first command in the queue
2236 // has a finite delay. So unless we are exiting it is safe to wait.
2237 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002238 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002239 if (waitTime == -1) {
2240 mWaitWorkCV.wait(mLock);
2241 } else {
2242 mWaitWorkCV.waitRelative(mLock, waitTime);
2243 }
Eric Laurent59a89232014-06-08 14:14:17 -07002244 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002245 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002246 // release delayed commands wake lock before quitting
2247 if (!mAudioCommands.isEmpty()) {
2248 release_wake_lock(mName.string());
2249 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002250 mLock.unlock();
2251 return false;
2252}
2253
2254status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2255{
2256 const size_t SIZE = 256;
2257 char buffer[SIZE];
2258 String8 result;
2259
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002260 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002261 if (!locked) {
2262 String8 result2(kCmdDeadlockedString);
2263 write(fd, result2.string(), result2.size());
2264 }
2265
2266 snprintf(buffer, SIZE, "- Commands:\n");
2267 result = String8(buffer);
2268 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002269 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002270 mAudioCommands[i]->dump(buffer, SIZE);
2271 result.append(buffer);
2272 }
2273 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002274 if (mLastCommand != 0) {
2275 mLastCommand->dump(buffer, SIZE);
2276 result.append(buffer);
2277 } else {
2278 result.append(" none\n");
2279 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002280
2281 write(fd, result.string(), result.size());
2282
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002283 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002284
2285 return NO_ERROR;
2286}
2287
Glenn Kastenfff6d712012-01-12 16:38:12 -08002288status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002289 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002290 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002291 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002292{
Eric Laurent0ede8922014-05-09 18:04:42 -07002293 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002294 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002295 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002296 data->mStream = stream;
2297 data->mVolume = volume;
2298 data->mIO = output;
2299 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002300 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002301 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002302 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002303 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002304}
2305
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002306status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002307 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002308 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002309{
Eric Laurent0ede8922014-05-09 18:04:42 -07002310 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002311 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002312 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002313 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002314 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002315 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002316 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002317 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002318 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002319 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002320}
2321
2322status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2323{
Eric Laurent0ede8922014-05-09 18:04:42 -07002324 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002325 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002326 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002327 data->mVolume = volume;
2328 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002329 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002330 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002331 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002332}
2333
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002334void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2335 audio_session_t sessionId,
2336 bool suspended)
2337{
2338 sp<AudioCommand> command = new AudioCommand();
2339 command->mCommand = SET_EFFECT_SUSPENDED;
2340 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2341 data->mEffectId = effectId;
2342 data->mSessionId = sessionId;
2343 data->mSuspended = suspended;
2344 command->mParam = data;
2345 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2346 effectId, sessionId, suspended);
2347 sendCommand(command);
2348}
2349
2350
Eric Laurentd7fe0862018-07-14 16:48:01 -07002351void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002352{
Eric Laurent0ede8922014-05-09 18:04:42 -07002353 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002354 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002355 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002356 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002357 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002358 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002359 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002360}
2361
Eric Laurentd7fe0862018-07-14 16:48:01 -07002362void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002363{
Eric Laurent0ede8922014-05-09 18:04:42 -07002364 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002365 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002366 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002367 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002368 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002369 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002370 sendCommand(command);
2371}
2372
Eric Laurent951f4552014-05-20 10:48:17 -07002373status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2374 const struct audio_patch *patch,
2375 audio_patch_handle_t *handle,
2376 int delayMs)
2377{
2378 status_t status = NO_ERROR;
2379
2380 sp<AudioCommand> command = new AudioCommand();
2381 command->mCommand = CREATE_AUDIO_PATCH;
2382 CreateAudioPatchData *data = new CreateAudioPatchData();
2383 data->mPatch = *patch;
2384 data->mHandle = *handle;
2385 command->mParam = data;
2386 command->mWaitStatus = true;
2387 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2388 status = sendCommand(command, delayMs);
2389 if (status == NO_ERROR) {
2390 *handle = data->mHandle;
2391 }
2392 return status;
2393}
2394
2395status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2396 int delayMs)
2397{
2398 sp<AudioCommand> command = new AudioCommand();
2399 command->mCommand = RELEASE_AUDIO_PATCH;
2400 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2401 data->mHandle = handle;
2402 command->mParam = data;
2403 command->mWaitStatus = true;
2404 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2405 return sendCommand(command, delayMs);
2406}
2407
Eric Laurentb52c1522014-05-20 11:27:36 -07002408void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2409{
2410 sp<AudioCommand> command = new AudioCommand();
2411 command->mCommand = UPDATE_AUDIOPORT_LIST;
2412 ALOGV("AudioCommandThread() adding update audio port list");
2413 sendCommand(command);
2414}
2415
Eric Laurented726cc2021-07-01 14:26:41 +02002416void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2417{
2418 sp<AudioCommand> command = new AudioCommand();
2419 command->mCommand = UPDATE_UID_STATES;
2420 ALOGV("AudioCommandThread() adding update UID states");
2421 sendCommand(command);
2422}
2423
Eric Laurentb52c1522014-05-20 11:27:36 -07002424void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2425{
2426 sp<AudioCommand>command = new AudioCommand();
2427 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2428 ALOGV("AudioCommandThread() adding update audio patch list");
2429 sendCommand(command);
2430}
2431
François Gaffiecfe17322018-11-07 13:41:29 +01002432void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2433 int flags)
2434{
2435 sp<AudioCommand>command = new AudioCommand();
2436 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2437 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2438 data->mGroup = group;
2439 data->mFlags = flags;
2440 command->mParam = data;
2441 ALOGV("AudioCommandThread() adding audio volume group changed");
2442 sendCommand(command);
2443}
2444
Eric Laurente1715a42014-05-20 11:30:42 -07002445status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2446 const struct audio_port_config *config, int delayMs)
2447{
2448 sp<AudioCommand> command = new AudioCommand();
2449 command->mCommand = SET_AUDIOPORT_CONFIG;
2450 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2451 data->mConfig = *config;
2452 command->mParam = data;
2453 command->mWaitStatus = true;
2454 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2455 return sendCommand(command, delayMs);
2456}
2457
Jean-Michel Trivide801052015-04-14 19:10:14 -07002458void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002459 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002460{
2461 sp<AudioCommand> command = new AudioCommand();
2462 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2463 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2464 data->mRegId = regId;
2465 data->mState = state;
2466 command->mParam = data;
2467 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2468 regId.string(), state);
2469 sendCommand(command);
2470}
2471
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002472void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002473 int event,
2474 const record_client_info_t *clientInfo,
2475 const audio_config_base_t *clientConfig,
2476 std::vector<effect_descriptor_t> clientEffects,
2477 const audio_config_base_t *deviceConfig,
2478 std::vector<effect_descriptor_t> effects,
2479 audio_patch_handle_t patchHandle,
2480 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002481{
2482 sp<AudioCommand>command = new AudioCommand();
2483 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2484 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2485 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002486 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002487 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002488 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002489 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002490 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002491 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002492 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002493 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002494 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2495 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002496 sendCommand(command);
2497}
2498
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002499void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2500{
2501 sp<AudioCommand> command = new AudioCommand();
2502 command->mCommand = AUDIO_MODULES_UPDATE;
2503 sendCommand(command);
2504}
2505
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002506void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2507{
2508 sp<AudioCommand>command = new AudioCommand();
2509 command->mCommand = ROUTING_UPDATED;
2510 ALOGV("AudioCommandThread() adding routing update");
2511 sendCommand(command);
2512}
2513
Eric Laurent81dd0f52021-07-05 11:54:40 +02002514void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2515{
2516 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002517 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002518 ALOGV("AudioCommandThread() adding check spatializer");
2519 sendCommand(command);
2520}
2521
Eric Laurent15903592022-02-24 20:44:36 +01002522void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2523{
2524 sp<AudioCommand>command = new AudioCommand();
2525 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2526 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2527 sendCommand(command);
2528}
2529
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002530void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2531{
2532 sp<AudioCommand>command = new AudioCommand();
2533 command->mCommand = VOL_RANGE_INIT_REQUEST;
2534 ALOGV("AudioCommandThread() adding volume range init request");
2535 sendCommand(command);
2536}
2537
Eric Laurent0ede8922014-05-09 18:04:42 -07002538status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2539{
2540 {
2541 Mutex::Autolock _l(mLock);
2542 insertCommand_l(command, delayMs);
2543 mWaitWorkCV.signal();
2544 }
2545 Mutex::Autolock _l(command->mLock);
2546 while (command->mWaitStatus) {
2547 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2548 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2549 command->mStatus = TIMED_OUT;
2550 command->mWaitStatus = false;
2551 }
2552 }
2553 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002554}
2555
Mathias Agopian65ab4712010-07-14 17:59:35 -07002556// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002557void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002558{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002559 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002560 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002561 command->mTime = systemTime() + milliseconds(delayMs);
2562
2563 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002564 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002565 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2566 }
2567
2568 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002569 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002570 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002571 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2572 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002573
2574 // create audio patch or release audio patch commands are equivalent
2575 // with regard to filtering
2576 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2577 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2578 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2579 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2580 continue;
2581 }
2582 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002583
2584 switch (command->mCommand) {
2585 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002586 ParametersData *data = (ParametersData *)command->mParam.get();
2587 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002588 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002589 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002590 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002591 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2592 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2593 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002594 String8 key;
2595 String8 value;
2596 param.getAt(j, key, value);
2597 for (size_t k = 0; k < param2.size(); k++) {
2598 String8 key2;
2599 String8 value2;
2600 param2.getAt(k, key2, value2);
2601 if (key2 == key) {
2602 param2.remove(key2);
2603 ALOGV("Filtering out parameter %s", key2.string());
2604 break;
2605 }
2606 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002607 }
2608 // if all keys have been filtered out, remove the command.
2609 // otherwise, update the key value pairs
2610 if (param2.size() == 0) {
2611 removedCommands.add(command2);
2612 } else {
2613 data2->mKeyValuePairs = param2.toString();
2614 }
Eric Laurent21e54562013-09-23 12:08:05 -07002615 command->mTime = command2->mTime;
2616 // force delayMs to non 0 so that code below does not request to wait for
2617 // command status as the command is now delayed
2618 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002619 } break;
2620
2621 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002622 VolumeData *data = (VolumeData *)command->mParam.get();
2623 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002624 if (data->mIO != data2->mIO) break;
2625 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002626 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002627 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002628 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002629 command->mTime = command2->mTime;
2630 // force delayMs to non 0 so that code below does not request to wait for
2631 // command status as the command is now delayed
2632 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002633 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002634
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002635 case SET_VOICE_VOLUME: {
2636 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2637 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2638 ALOGV("Filtering out voice volume command value %f replaced by %f",
2639 data2->mVolume, data->mVolume);
2640 removedCommands.add(command2);
2641 command->mTime = command2->mTime;
2642 // force delayMs to non 0 so that code below does not request to wait for
2643 // command status as the command is now delayed
2644 delayMs = 1;
2645 } break;
2646
Eric Laurente45b48a2014-09-04 16:40:57 -07002647 case CREATE_AUDIO_PATCH:
2648 case RELEASE_AUDIO_PATCH: {
2649 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002650 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002651 if (command->mCommand == CREATE_AUDIO_PATCH) {
2652 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002653 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002654 } else {
2655 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002656 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002657 }
2658 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002659 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002660 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2661 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002662 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002663 } else {
2664 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002665 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002666 }
2667 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002668 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2669 same output. */
2670 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2671 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2672 bool isOutputDiff = false;
2673 if (patch.num_sources == patch2.num_sources) {
2674 for (unsigned count = 0; count < patch.num_sources; count++) {
2675 if (patch.sources[count].id != patch2.sources[count].id) {
2676 isOutputDiff = true;
2677 break;
2678 }
2679 }
2680 if (isOutputDiff)
2681 break;
2682 }
2683 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002684 ALOGV("Filtering out %s audio patch command for handle %d",
2685 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2686 removedCommands.add(command2);
2687 command->mTime = command2->mTime;
2688 // force delayMs to non 0 so that code below does not request to wait for
2689 // command status as the command is now delayed
2690 delayMs = 1;
2691 } break;
2692
Jean-Michel Trivide801052015-04-14 19:10:14 -07002693 case DYN_POLICY_MIX_STATE_UPDATE: {
2694
2695 } break;
2696
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002697 case RECORDING_CONFIGURATION_UPDATE: {
2698
2699 } break;
2700
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002701 case ROUTING_UPDATED: {
2702
2703 } break;
2704
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002705 case VOL_RANGE_INIT_REQUEST: {
2706 // command may come from different requests, do not filter
2707 } break;
2708
Mathias Agopian65ab4712010-07-14 17:59:35 -07002709 default:
2710 break;
2711 }
2712 }
2713
2714 // remove filtered commands
2715 for (size_t j = 0; j < removedCommands.size(); j++) {
2716 // removed commands always have time stamps greater than current command
2717 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002718 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002719 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002720 mAudioCommands.removeAt(k);
2721 break;
2722 }
2723 }
2724 }
2725 removedCommands.clear();
2726
Eric Laurentaa79bef2015-01-15 14:33:51 -08002727 // Disable wait for status if delay is not 0.
2728 // Except for create audio patch command because the returned patch handle
2729 // is needed by audio policy manager
2730 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002731 command->mWaitStatus = false;
2732 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002733
Mathias Agopian65ab4712010-07-14 17:59:35 -07002734 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002735 ALOGV("inserting command: %d at index %zd, num commands %zu",
2736 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002737 mAudioCommands.insertAt(command, i + 1);
2738}
2739
2740void AudioPolicyService::AudioCommandThread::exit()
2741{
Steve Block3856b092011-10-20 11:56:00 +01002742 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002743 {
2744 AutoMutex _l(mLock);
2745 requestExit();
2746 mWaitWorkCV.signal();
2747 }
Zach Janga754b4f2015-10-27 01:29:34 +00002748 // Note that we can call it from the thread loop if all other references have been released
2749 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002750 requestExitAndWait();
2751}
2752
2753void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2754{
2755 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2756 mCommand,
2757 (int)ns2s(mTime),
2758 (int)ns2ms(mTime)%1000,
2759 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002760 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002761}
2762
Dima Zavinfce7a472011-04-19 22:30:36 -07002763/******* helpers for the service_ops callbacks defined below *********/
2764void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2765 const char *keyValuePairs,
2766 int delayMs)
2767{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002768 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002769 delayMs);
2770}
2771
2772int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2773 float volume,
2774 audio_io_handle_t output,
2775 int delayMs)
2776{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002777 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002778 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002779}
2780
Dima Zavinfce7a472011-04-19 22:30:36 -07002781int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2782{
2783 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2784}
2785
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002786void AudioPolicyService::setEffectSuspended(int effectId,
2787 audio_session_t sessionId,
2788 bool suspended)
2789{
2790 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2791}
2792
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002793Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002794{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002795 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002796 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002797}
2798
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002799
Dima Zavinfce7a472011-04-19 22:30:36 -07002800extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002801audio_module_handle_t aps_load_hw_module(void *service __unused,
2802 const char *name);
2803audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002804 audio_devices_t *pDevices,
2805 uint32_t *pSamplingRate,
2806 audio_format_t *pFormat,
2807 audio_channel_mask_t *pChannelMask,
2808 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002809 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002810
Eric Laurent2d388ec2014-03-07 13:25:54 -08002811audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002812 audio_module_handle_t module,
2813 audio_devices_t *pDevices,
2814 uint32_t *pSamplingRate,
2815 audio_format_t *pFormat,
2816 audio_channel_mask_t *pChannelMask,
2817 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002818 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002819 const audio_offload_info_t *offloadInfo);
2820audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002821 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002822 audio_io_handle_t output2);
2823int aps_close_output(void *service __unused, audio_io_handle_t output);
2824int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2825int aps_restore_output(void *service __unused, audio_io_handle_t output);
2826audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002827 audio_devices_t *pDevices,
2828 uint32_t *pSamplingRate,
2829 audio_format_t *pFormat,
2830 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002831 audio_in_acoustics_t acoustics __unused);
2832audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002833 audio_module_handle_t module,
2834 audio_devices_t *pDevices,
2835 uint32_t *pSamplingRate,
2836 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002837 audio_channel_mask_t *pChannelMask);
2838int aps_close_input(void *service __unused, audio_io_handle_t input);
2839int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002840int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002841 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002842 audio_io_handle_t dst_output);
2843char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2844 const char *keys);
2845void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2846 const char *kv_pairs, int delay_ms);
2847int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002848 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002849 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002850int aps_set_voice_volume(void *service, float volume, int delay_ms);
2851};
Dima Zavinfce7a472011-04-19 22:30:36 -07002852
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002853} // namespace android