blob: 6f23fe773a86320faa6a9febf628a6a4dc9842cd [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
Eric Laurent4ab18412022-11-07 16:25:32 +01001009 bool allowSensitiveCapture =
1010 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001011 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001012 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001013 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001014 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001015
Eric Laurented726cc2021-07-01 14:26:41 +02001016 if (!current->hasOp()) {
1017 // Never allow capture if app op is denied
1018 allowCapture = false;
1019 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001020 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1021 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001022 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001023 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001024 // Active assistant list is not being used
1025 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001026 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001027 // OR there is no active privacy sensitive capture or call
1028 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1029 // AND is latest TOP assistant AND
1030 // uses VOICE_RECOGNITION OR uses HOTWORD
1031 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001032 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001033 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001034 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001035 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001036 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001037 && canCaptureIfInCallOrCommunication(current)) {
1038 if (isTopOrLatestAssistant
1039 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1040 || source == AUDIO_SOURCE_HOTWORD)) {
1041 allowCapture = true;
1042 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1043 allowCapture = true;
1044 }
1045 }
1046 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1047 // For assistant on active list and on top allow capture if:
1048 // An accessibility service is on TOP
1049 // AND the source is VOICE_RECOGNITION or HOTWORD
1050 // OR there is no active privacy sensitive capture or call
1051 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1052 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1053 if (isA11yOnTop) {
1054 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1055 allowCapture = true;
1056 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001057 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001058 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001059 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1060 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001061 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001062 }
1063 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001064 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001065 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001066 // The assistant is not on TOP
1067 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001068 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001069 // OR
1070 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1071 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001072 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001073 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001074 allowCapture = true;
1075 }
Eric Laurent589171c2019-07-25 18:04:29 -07001076 if (isA11yOnTop) {
1077 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1078 allowCapture = true;
1079 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001080 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001081 } else if (source == AUDIO_SOURCE_HOTWORD) {
1082 // For HOTWORD source allow capture when not on TOP if:
1083 // All active clients are using HOTWORD source
1084 // AND no call is active
1085 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001086 if (onlyHotwordActive
1087 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001088 allowCapture = true;
1089 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001090 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001091 // For current InputMethodService allow capture if:
1092 // A RTT call is active AND the source is VOICE_RECOGNITION
1093 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1094 allowCapture = true;
1095 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001096 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001097 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001098 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001099 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001100 }
1101}
1102
Michael Groovercfd28302018-12-11 19:16:46 -08001103void AudioPolicyService::silenceAllRecordings_l() {
1104 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1105 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001106 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001107 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001108 }
Michael Groovercfd28302018-12-11 19:16:46 -08001109 }
1110}
1111
Eric Laurente8c8b432018-10-17 10:08:02 -07001112/* static */
1113app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001114
1115 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001116 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001117 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1118 // include persistent services
1119 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001120 }
1121 return APP_STATE_FOREGROUND;
1122}
1123
Eric Laurent4eb58f12018-12-07 16:41:02 -08001124/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001125bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001126{
1127 switch (source) {
1128 case AUDIO_SOURCE_VOICE_UPLINK:
1129 case AUDIO_SOURCE_VOICE_DOWNLINK:
1130 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001131 case AUDIO_SOURCE_REMOTE_SUBMIX:
1132 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001133 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001134 return true;
1135 default:
1136 break;
1137 }
1138 return false;
1139}
1140
Eric Laurented726cc2021-07-01 14:26:41 +02001141/* static */
1142bool AudioPolicyService::isAppOpSource(audio_source_t source)
1143{
1144 switch (source) {
1145 case AUDIO_SOURCE_FM_TUNER:
1146 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001147 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001148 return false;
1149 default:
1150 break;
1151 }
1152 return true;
1153}
1154
Eric Laurent8c7ef892021-06-10 13:32:16 +02001155void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001156{
1157 AutoCallerClear acc;
1158
1159 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001160 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001161 }
1162 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1163 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001164 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001165 if (client->silenced != silenced) {
1166 if (client->active) {
1167 if (silenced) {
1168 finishRecording(client->attributionSource, client->attributes.source);
1169 } else {
1170 std::stringstream msg;
1171 msg << "Audio recording un-silenced on session " << client->session;
1172 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1173 client->attributes.source)) {
1174 silenced = true;
1175 }
1176 }
1177 }
1178 af->setRecordSilenced(client->portId, silenced);
1179 client->silenced = silenced;
1180 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001181 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001182}
1183
Glenn Kasten0f11b512014-01-31 16:18:54 -08001184status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001185{
Glenn Kasten44deb052012-02-05 18:09:08 -08001186 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001187 dumpPermissionDenial(fd);
1188 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001189 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001190 if (!locked) {
1191 String8 result(kDeadlockedString);
1192 write(fd, result.string(), result.size());
1193 }
1194
1195 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001196
1197 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1198 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001199 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001200 mAudioCommandThread->dump(fd);
1201 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001202
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001203 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1204 write(fd, octPtr.string(), octPtr.size());
1205 if (mOutputCommandThread != 0) {
1206 mOutputCommandThread->dump(fd);
1207 }
1208
Eric Laurentdce54a12014-03-10 12:19:46 -07001209 if (mAudioPolicyManager) {
1210 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001211 } else {
1212 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1213 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001214 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215
Kevin Rocard8be94972019-02-22 13:26:25 -08001216 mPackageManager.dump(fd);
1217
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001218 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001219
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001220 if (mSpatializer != nullptr) {
1221 std::string dumpString = mSpatializer->toString(1 /* level */);
1222 write(fd, dumpString.c_str(), dumpString.size());
1223 } else {
1224 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1225 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1226 }
1227
Andy Hungc747c532022-03-07 21:41:14 -08001228 {
1229 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1230 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1231 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1232 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001233 }
1234 return NO_ERROR;
1235}
1236
1237status_t AudioPolicyService::dumpPermissionDenial(int fd)
1238{
1239 const size_t SIZE = 256;
1240 char buffer[SIZE];
1241 String8 result;
1242 snprintf(buffer, SIZE, "Permission Denial: "
1243 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1244 IPCThreadState::self()->getCallingPid(),
1245 IPCThreadState::self()->getCallingUid());
1246 result.append(buffer);
1247 write(fd, result.string(), result.size());
1248 return NO_ERROR;
1249}
1250
1251status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001252 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001253 // make sure transactions reserved to AudioFlinger do not come from other processes
1254 switch (code) {
1255 case TRANSACTION_startOutput:
1256 case TRANSACTION_stopOutput:
1257 case TRANSACTION_releaseOutput:
1258 case TRANSACTION_getInputForAttr:
1259 case TRANSACTION_startInput:
1260 case TRANSACTION_stopInput:
1261 case TRANSACTION_releaseInput:
1262 case TRANSACTION_getOutputForEffect:
1263 case TRANSACTION_registerEffect:
1264 case TRANSACTION_unregisterEffect:
1265 case TRANSACTION_setEffectEnabled:
1266 case TRANSACTION_getStrategyForStream:
1267 case TRANSACTION_getOutputForAttr:
1268 case TRANSACTION_moveEffectsToIo:
1269 ALOGW("%s: transaction %d received from PID %d",
1270 __func__, code, IPCThreadState::self()->getCallingPid());
1271 return INVALID_OPERATION;
1272 default:
1273 break;
1274 }
1275
1276 // make sure the following transactions come from system components
1277 switch (code) {
1278 case TRANSACTION_setDeviceConnectionState:
1279 case TRANSACTION_handleDeviceConfigChange:
1280 case TRANSACTION_setPhoneState:
1281//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1282// case TRANSACTION_setForceUse:
1283 case TRANSACTION_initStreamVolume:
1284 case TRANSACTION_setStreamVolumeIndex:
1285 case TRANSACTION_setVolumeIndexForAttributes:
1286 case TRANSACTION_getStreamVolumeIndex:
1287 case TRANSACTION_getVolumeIndexForAttributes:
1288 case TRANSACTION_getMinVolumeIndexForAttributes:
1289 case TRANSACTION_getMaxVolumeIndexForAttributes:
1290 case TRANSACTION_isStreamActive:
1291 case TRANSACTION_isStreamActiveRemotely:
1292 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001293 case TRANSACTION_registerPolicyMixes:
1294 case TRANSACTION_setMasterMono:
1295 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001296 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001297 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001298 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001299 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001300 case TRANSACTION_setA11yServicesUids:
1301 case TRANSACTION_setUidDeviceAffinities:
1302 case TRANSACTION_removeUidDeviceAffinities:
1303 case TRANSACTION_setUserIdDeviceAffinities:
1304 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001305 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001306 case TRANSACTION_listAudioVolumeGroups:
1307 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1308 case TRANSACTION_acquireSoundTriggerSession:
1309 case TRANSACTION_releaseSoundTriggerSession:
1310 case TRANSACTION_setRttEnabled:
1311 case TRANSACTION_isCallScreenModeSupported:
1312 case TRANSACTION_setDevicesRoleForStrategy:
1313 case TRANSACTION_setSupportedSystemUsages:
1314 case TRANSACTION_removeDevicesRoleForStrategy:
1315 case TRANSACTION_getDevicesForRoleAndStrategy:
1316 case TRANSACTION_getDevicesForAttributes:
1317 case TRANSACTION_setAllowedCapturePolicy:
1318 case TRANSACTION_onNewAudioModulesAvailable:
1319 case TRANSACTION_setCurrentImeUid:
1320 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1321 case TRANSACTION_setDevicesRoleForCapturePreset:
1322 case TRANSACTION_addDevicesRoleForCapturePreset:
1323 case TRANSACTION_removeDevicesRoleForCapturePreset:
1324 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001325 case TRANSACTION_getDevicesForRoleAndCapturePreset:
1326 case TRANSACTION_getSpatializer: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001327 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1328 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1329 __func__, code, IPCThreadState::self()->getCallingPid(),
1330 IPCThreadState::self()->getCallingUid());
1331 return INVALID_OPERATION;
1332 }
1333 } break;
1334 default:
1335 break;
1336 }
1337
Andy Hungc747c532022-03-07 21:41:14 -08001338 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1339 mediautils::TimeCheck check(
1340 std::string("IAudioPolicyService::").append(methodName),
1341 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1342 if (timeout) {
1343 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1344 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1345 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1346 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1347 .record();
1348 } else {
1349 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1350 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001351 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1352 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1353 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001354
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001355 switch (code) {
1356 case SHELL_COMMAND_TRANSACTION: {
1357 int in = data.readFileDescriptor();
1358 int out = data.readFileDescriptor();
1359 int err = data.readFileDescriptor();
1360 int argc = data.readInt32();
1361 Vector<String16> args;
1362 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1363 args.add(data.readString16());
1364 }
1365 sp<IBinder> unusedCallback;
1366 sp<IResultReceiver> resultReceiver;
1367 status_t status;
1368 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1369 return status;
1370 }
1371 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1372 return status;
1373 }
1374 status = shellCommand(in, out, err, args);
1375 if (resultReceiver != nullptr) {
1376 resultReceiver->send(status);
1377 }
1378 return NO_ERROR;
1379 }
1380 }
1381
Mathias Agopian65ab4712010-07-14 17:59:35 -07001382 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1383}
1384
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001385// ------------------- Shell command implementation -------------------
1386
1387// NOTE: This is a remote API - make sure all args are validated
1388status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1389 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1390 return PERMISSION_DENIED;
1391 }
1392 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1393 return BAD_VALUE;
1394 }
jovanakbe066e12019-09-02 11:54:39 -07001395 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001396 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001397 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001398 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001399 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001400 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001401 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1402 purgePermissionCache();
1403 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001404 } else if (args.size() == 1 && args[0] == String16("help")) {
1405 printHelp(out);
1406 return NO_ERROR;
1407 }
1408 printHelp(err);
1409 return BAD_VALUE;
1410}
1411
jovanakbe066e12019-09-02 11:54:39 -07001412static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1413 if (userId < 0) {
1414 ALOGE("Invalid user: %d", userId);
1415 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001416 return BAD_VALUE;
1417 }
jovanakbe066e12019-09-02 11:54:39 -07001418
1419 PermissionController pc;
1420 uid = pc.getPackageUid(packageName, 0);
1421 if (uid <= 0) {
1422 ALOGE("Unknown package: '%s'", String8(packageName).string());
1423 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1424 return BAD_VALUE;
1425 }
1426
1427 uid = multiuser_get_uid(userId, uid);
1428 return NO_ERROR;
1429}
1430
1431status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1432 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1433 if (!(args.size() == 3 || args.size() == 5)) {
1434 printHelp(err);
1435 return BAD_VALUE;
1436 }
1437
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001438 bool active = false;
1439 if (args[2] == String16("active")) {
1440 active = true;
1441 } else if ((args[2] != String16("idle"))) {
1442 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1443 return BAD_VALUE;
1444 }
jovanakbe066e12019-09-02 11:54:39 -07001445
1446 int userId = 0;
1447 if (args.size() >= 5 && args[3] == String16("--user")) {
1448 userId = atoi(String8(args[4]));
1449 }
1450
1451 uid_t uid;
1452 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1453 return BAD_VALUE;
1454 }
1455
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001456 sp<UidPolicy> uidPolicy;
1457 {
1458 Mutex::Autolock _l(mLock);
1459 uidPolicy = mUidPolicy;
1460 }
1461 if (uidPolicy) {
1462 uidPolicy->addOverrideUid(uid, active);
1463 return NO_ERROR;
1464 }
1465 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001466}
1467
1468status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001469 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1470 if (!(args.size() == 2 || args.size() == 4)) {
1471 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001472 return BAD_VALUE;
1473 }
jovanakbe066e12019-09-02 11:54:39 -07001474
1475 int userId = 0;
1476 if (args.size() >= 4 && args[2] == String16("--user")) {
1477 userId = atoi(String8(args[3]));
1478 }
1479
1480 uid_t uid;
1481 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1482 return BAD_VALUE;
1483 }
1484
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001485 sp<UidPolicy> uidPolicy;
1486 {
1487 Mutex::Autolock _l(mLock);
1488 uidPolicy = mUidPolicy;
1489 }
1490 if (uidPolicy) {
1491 uidPolicy->removeOverrideUid(uid);
1492 return NO_ERROR;
1493 }
1494 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001495}
1496
1497status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001498 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1499 if (!(args.size() == 2 || args.size() == 4)) {
1500 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001501 return BAD_VALUE;
1502 }
jovanakbe066e12019-09-02 11:54:39 -07001503
1504 int userId = 0;
1505 if (args.size() >= 4 && args[2] == String16("--user")) {
1506 userId = atoi(String8(args[3]));
1507 }
1508
1509 uid_t uid;
1510 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1511 return BAD_VALUE;
1512 }
1513
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001514 sp<UidPolicy> uidPolicy;
1515 {
1516 Mutex::Autolock _l(mLock);
1517 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001518 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001519 if (uidPolicy) {
1520 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1521 }
1522 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001523}
1524
1525status_t AudioPolicyService::printHelp(int out) {
1526 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001527 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1528 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1529 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001530 " help print this message\n");
1531}
1532
1533// ----------- AudioPolicyService::UidPolicy implementation ----------
1534
1535void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001536 status_t res = mAm.linkToDeath(this);
1537 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001538 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001539 | ActivityManager::UID_OBSERVER_ACTIVE
1540 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001541 ActivityManager::PROCESS_STATE_UNKNOWN,
1542 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001543 if (!res) {
1544 Mutex::Autolock _l(mLock);
1545 mObserverRegistered = true;
1546 } else {
1547 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001548
Steven Moreland2f348142019-07-02 15:59:07 -07001549 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001550 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001551}
1552
1553void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001554 mAm.unlinkToDeath(this);
1555 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001556 Mutex::Autolock _l(mLock);
1557 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001558}
1559
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001560void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1561 Mutex::Autolock _l(mLock);
1562 mCachedUids.clear();
1563 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001564}
1565
Eric Laurente8c8b432018-10-17 10:08:02 -07001566void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001567 bool needToReregister = false;
1568 {
1569 Mutex::Autolock _l(mLock);
1570 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001571 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001572 if (needToReregister) {
1573 // Looks like ActivityManager has died previously, attempt to re-register.
1574 registerSelf();
1575 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001576}
1577
1578bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1579 if (isServiceUid(uid)) return true;
1580 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001581 {
1582 Mutex::Autolock _l(mLock);
1583 auto overrideIter = mOverrideUids.find(uid);
1584 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001585 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001586 }
1587 // In an absense of the ActivityManager, assume everything to be active.
1588 if (!mObserverRegistered) return true;
1589 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001590 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001591 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001592 }
1593 }
1594 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001595 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001596 {
1597 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001598 mCachedUids.insert(std::pair<uid_t,
1599 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1600 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001601 }
1602 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001603}
1604
Eric Laurente8c8b432018-10-17 10:08:02 -07001605int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1606 if (isServiceUid(uid)) {
1607 return ActivityManager::PROCESS_STATE_TOP;
1608 }
1609 checkRegistered();
1610 {
1611 Mutex::Autolock _l(mLock);
1612 auto overrideIter = mOverrideUids.find(uid);
1613 if (overrideIter != mOverrideUids.end()) {
1614 if (overrideIter->second.first) {
1615 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1616 return overrideIter->second.second;
1617 } else {
1618 auto cacheIter = mCachedUids.find(uid);
1619 if (cacheIter != mCachedUids.end()) {
1620 return cacheIter->second.second;
1621 }
1622 }
1623 }
1624 return ActivityManager::PROCESS_STATE_UNKNOWN;
1625 }
1626 // In an absense of the ActivityManager, assume everything to be active.
1627 if (!mObserverRegistered) {
1628 return ActivityManager::PROCESS_STATE_TOP;
1629 }
1630 auto cacheIter = mCachedUids.find(uid);
1631 if (cacheIter != mCachedUids.end()) {
1632 if (cacheIter->second.first) {
1633 return cacheIter->second.second;
1634 } else {
1635 return ActivityManager::PROCESS_STATE_UNKNOWN;
1636 }
1637 }
1638 }
1639 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001640 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001641 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1642 if (active) {
1643 state = am.getUidProcessState(uid, String16("audioserver"));
1644 }
1645 {
1646 Mutex::Autolock _l(mLock);
1647 mCachedUids.insert(std::pair<uid_t,
1648 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1649 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001650
Eric Laurente8c8b432018-10-17 10:08:02 -07001651 return state;
1652}
1653
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001654void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001655 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001656}
1657
1658void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001659 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001660}
1661
1662void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001663 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001664}
1665
Eric Laurente8c8b432018-10-17 10:08:02 -07001666void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1667 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001668 int64_t procStateSeq __unused,
1669 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001670 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1671 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001672 }
1673}
1674
Austin Borger65577682022-02-17 00:25:43 +00001675void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1676}
1677
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001678void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001679 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1680}
1681
1682void AudioPolicyService::UidPolicy::notifyService() {
1683 sp<AudioPolicyService> service = mService.promote();
1684 if (service != nullptr) {
1685 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001686 }
1687}
1688
Eric Laurente8c8b432018-10-17 10:08:02 -07001689void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1690 std::pair<bool, int>> *uids,
1691 uid_t uid,
1692 bool active,
1693 int state,
1694 bool insert) {
1695 if (isServiceUid(uid)) {
1696 return;
1697 }
1698 bool wasActive = isUidActive(uid);
1699 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001700 {
1701 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001702 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001703 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001704 if (wasActive != isUidActive(uid) || state != previousState) {
1705 notifyService();
1706 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001707}
1708
Eric Laurente8c8b432018-10-17 10:08:02 -07001709void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1710 std::pair<bool, int>> *uids,
1711 uid_t uid,
1712 bool active,
1713 int state,
1714 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001715 auto it = uids->find(uid);
1716 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001717 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001718 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1719 it->second.first = active;
1720 }
1721 if (it->second.first) {
1722 it->second.second = state;
1723 } else {
1724 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1725 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001726 } else {
1727 uids->erase(it);
1728 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001729 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1730 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1731 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001732 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001733}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001734
Eric Laurent4eb58f12018-12-07 16:41:02 -08001735bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001736 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001737 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001738 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001739 continue;
1740 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001741 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1742 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001743 return true;
1744 }
1745 }
1746 return false;
1747}
1748
Eric Laurentb78763e2018-10-17 10:08:02 -07001749bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1750{
1751 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1752 return it != mA11yUids.end();
1753}
1754
Oscar Azucena829d90d2022-01-28 17:17:56 -08001755void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1756 mAssistantUids.clear();
1757 mAssistantUids = uids;
1758}
1759
1760bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1761{
1762 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1763 return it != mAssistantUids.end();
1764}
1765
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001766void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1767 mActiveAssistantUids = activeUids;
1768}
1769
1770bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1771{
1772 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1773 mActiveAssistantUids.end(), uid);
1774 return it != mActiveAssistantUids.end();
1775}
1776
Oscar Azucena829d90d2022-01-28 17:17:56 -08001777void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1778 const size_t SIZE = 256;
1779 char buffer[SIZE];
1780 String8 result;
1781 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1782 snprintf(buffer, SIZE, "\t%s: \n", title);
1783 result.append(buffer);
1784 int counter = 0;
1785 if (uids.empty()) {
1786 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1787 result.append(buffer);
1788 return;
1789 }
1790 for (const auto &uid : uids) {
1791 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1792 result.append(buffer);
1793 }
1794 };
1795
1796 snprintf(buffer, SIZE, "UID Policy:\n");
1797 result.append(buffer);
1798 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1799 result.append(buffer);
1800
1801 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001802 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001803
1804 appendUidsToResult("Accessibility UIDs", mA11yUids);
1805
1806 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1807 result.append(buffer);
1808
1809 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1810 result.append(buffer);
1811
1812 write(fd, result.string(), result.size());
1813}
1814
Michael Groovercfd28302018-12-11 19:16:46 -08001815// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1816void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1817 SensorPrivacyManager spm;
1818 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1819 spm.addSensorPrivacyListener(this);
1820}
1821
1822void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1823 SensorPrivacyManager spm;
1824 spm.removeSensorPrivacyListener(this);
1825}
1826
1827bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1828 return mSensorPrivacyEnabled;
1829}
1830
Evan Seversond8dc6832022-01-27 10:47:03 -08001831binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1832 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001833 mSensorPrivacyEnabled = enabled;
1834 sp<AudioPolicyService> service = mService.promote();
1835 if (service != nullptr) {
1836 service->updateUidStates();
1837 }
1838 return binder::Status::ok();
1839}
1840
Eric Laurented726cc2021-07-01 14:26:41 +02001841// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1842
1843// static
1844sp<AudioPolicyService::OpRecordAudioMonitor>
1845AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1846 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1847 wp<AudioCommandThread> commandThread)
1848{
Eric Laurent987ce102021-07-05 12:11:51 +02001849 if (isAudioServerOrRootUid(attributionSource.uid)) {
1850 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001851 attributionSource.toString().c_str());
1852 return nullptr;
1853 }
1854
1855 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1856 ALOGD("not monitoring app op for uid %d and source %d",
1857 attributionSource.uid, attr.source);
1858 return nullptr;
1859 }
1860
1861 if (!attributionSource.packageName.has_value()
1862 || attributionSource.packageName.value().size() == 0) {
1863 return nullptr;
1864 }
1865 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1866}
1867
1868AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1869 const AttributionSourceState& attributionSource, int32_t appOp,
1870 wp<AudioCommandThread> commandThread) :
1871 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1872 mCommandThread(commandThread)
1873{
1874}
1875
1876AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1877{
1878 if (mOpCallback != 0) {
1879 mAppOpsManager.stopWatchingMode(mOpCallback);
1880 }
1881 mOpCallback.clear();
1882}
1883
1884void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1885{
1886 checkOp();
1887 mOpCallback = new RecordAudioOpCallback(this);
1888 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1889 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1890 // since it controls the mic permission for legacy apps.
1891 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1892 mAttributionSource.packageName.value_or(""))),
1893 mOpCallback);
1894}
1895
1896bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1897 return mHasOp.load();
1898}
1899
1900// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1901// is updated in AppOp callback and in onFirstRef()
1902// Note this method is never called (and never to be) for audio server / root track
1903// due to the UID in createIfNeeded(). As a result for those record track, it's:
1904// - not called from constructor,
1905// - not called from RecordAudioOpCallback because the callback is not installed in this case
1906void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1907{
1908 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1909 // since it controls the mic permission for legacy apps.
1910 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1911 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1912 mAttributionSource.packageName.value_or(""))));
1913 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1914 // verbose logging only log when appOp changed
1915 ALOGI_IF(hasIt != mHasOp.load(),
1916 "App op %d missing, %ssilencing record %s",
1917 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1918 mHasOp.store(hasIt);
1919
1920 if (updateUidStates) {
1921 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1922 if (commandThread != nullptr) {
1923 commandThread->updateUidStatesCommand();
1924 }
1925 }
1926}
1927
1928AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1929 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1930{ }
1931
1932void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1933 const String16& packageName __unused) {
1934 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1935 if (monitor != NULL) {
1936 if (op != monitor->getOp()) {
1937 return;
1938 }
1939 monitor->checkOp(true);
1940 }
1941}
1942
1943
Mathias Agopian65ab4712010-07-14 17:59:35 -07001944// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1945
Eric Laurentbfb1b832013-01-07 09:53:42 -08001946AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1947 const wp<AudioPolicyService>& service)
1948 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001949{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001950}
1951
1952
1953AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1954{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001955 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001956 release_wake_lock(mName.string());
1957 }
1958 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001959}
1960
1961void AudioPolicyService::AudioCommandThread::onFirstRef()
1962{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001963 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001964}
1965
1966bool AudioPolicyService::AudioCommandThread::threadLoop()
1967{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001968 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001969
1970 mLock.lock();
1971 while (!exitPending())
1972 {
Eric Laurent59a89232014-06-08 14:14:17 -07001973 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001974 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001975 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001976 nsecs_t curTime = systemTime();
1977 // commands are sorted by increasing time stamp: execute them from index 0 and up
1978 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001979 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001980 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001981 if (mAudioCommands.isEmpty()) {
1982 ++numTimesBecameEmpty;
1983 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001984 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001985
1986 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001987 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001988 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001989 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001990 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001991 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001992 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1993 data->mVolume,
1994 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001995 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001996 }break;
1997 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001998 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001999 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2000 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002001 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002002 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002003 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002004 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002005 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002006 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002007 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002008 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002009 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002010 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002011 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002012 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002013 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002014 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002015 ALOGV("AudioCommandThread() processing stop output portId %d",
2016 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002017 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002018 if (svc == 0) {
2019 break;
2020 }
2021 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002022 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002023 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002024 }break;
2025 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002026 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002027 ALOGV("AudioCommandThread() processing release output portId %d",
2028 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002029 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002030 if (svc == 0) {
2031 break;
2032 }
2033 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002034 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002035 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002036 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002037 case CREATE_AUDIO_PATCH: {
2038 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2039 ALOGV("AudioCommandThread() processing create audio patch");
2040 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2041 if (af == 0) {
2042 command->mStatus = PERMISSION_DENIED;
2043 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002044 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002045 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002046 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002047 }
2048 } break;
2049 case RELEASE_AUDIO_PATCH: {
2050 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2051 ALOGV("AudioCommandThread() processing release audio patch");
2052 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2053 if (af == 0) {
2054 command->mStatus = PERMISSION_DENIED;
2055 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002056 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002057 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002058 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002059 }
2060 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002061 case UPDATE_AUDIOPORT_LIST: {
2062 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002063 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002064 if (svc == 0) {
2065 break;
2066 }
2067 mLock.unlock();
2068 svc->doOnAudioPortListUpdate();
2069 mLock.lock();
2070 }break;
2071 case UPDATE_AUDIOPATCH_LIST: {
2072 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002073 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002074 if (svc == 0) {
2075 break;
2076 }
2077 mLock.unlock();
2078 svc->doOnAudioPatchListUpdate();
2079 mLock.lock();
2080 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002081 case CHANGED_AUDIOVOLUMEGROUP: {
2082 AudioVolumeGroupData *data =
2083 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2084 ALOGV("AudioCommandThread() processing update audio volume group");
2085 svc = mService.promote();
2086 if (svc == 0) {
2087 break;
2088 }
2089 mLock.unlock();
2090 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2091 mLock.lock();
2092 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002093 case SET_AUDIOPORT_CONFIG: {
2094 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2095 ALOGV("AudioCommandThread() processing set port config");
2096 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2097 if (af == 0) {
2098 command->mStatus = PERMISSION_DENIED;
2099 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002100 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002101 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002102 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002103 }
2104 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002105 case DYN_POLICY_MIX_STATE_UPDATE: {
2106 DynPolicyMixStateUpdateData *data =
2107 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002108 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2109 data->mRegId.string(), data->mState);
2110 svc = mService.promote();
2111 if (svc == 0) {
2112 break;
2113 }
2114 mLock.unlock();
2115 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2116 mLock.lock();
2117 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002118 case RECORDING_CONFIGURATION_UPDATE: {
2119 RecordingConfigurationUpdateData *data =
2120 (RecordingConfigurationUpdateData *)command->mParam.get();
2121 ALOGV("AudioCommandThread() processing recording configuration update");
2122 svc = mService.promote();
2123 if (svc == 0) {
2124 break;
2125 }
2126 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002127 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002128 &data->mClientConfig, data->mClientEffects,
2129 &data->mDeviceConfig, data->mEffects,
2130 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002131 mLock.lock();
2132 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002133 case SET_EFFECT_SUSPENDED: {
2134 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2135 ALOGV("AudioCommandThread() processing set effect suspended");
2136 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2137 if (af != 0) {
2138 mLock.unlock();
2139 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2140 mLock.lock();
2141 }
2142 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002143 case AUDIO_MODULES_UPDATE: {
2144 ALOGV("AudioCommandThread() processing audio modules update");
2145 svc = mService.promote();
2146 if (svc == 0) {
2147 break;
2148 }
2149 mLock.unlock();
2150 svc->doOnNewAudioModulesAvailable();
2151 mLock.lock();
2152 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002153 case ROUTING_UPDATED: {
2154 ALOGV("AudioCommandThread() processing routing update");
2155 svc = mService.promote();
2156 if (svc == 0) {
2157 break;
2158 }
2159 mLock.unlock();
2160 svc->doOnRoutingUpdated();
2161 mLock.lock();
2162 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002163
Eric Laurented726cc2021-07-01 14:26:41 +02002164 case UPDATE_UID_STATES: {
2165 ALOGV("AudioCommandThread() processing updateUID states");
2166 svc = mService.promote();
2167 if (svc == 0) {
2168 break;
2169 }
2170 mLock.unlock();
2171 svc->updateUidStates();
2172 mLock.lock();
2173 } break;
2174
Eric Laurent15903592022-02-24 20:44:36 +01002175 case CHECK_SPATIALIZER_OUTPUT: {
2176 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002177 svc = mService.promote();
2178 if (svc == 0) {
2179 break;
2180 }
2181 mLock.unlock();
2182 svc->doOnCheckSpatializer();
2183 mLock.lock();
2184 } break;
2185
Eric Laurent15903592022-02-24 20:44:36 +01002186 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2187 ALOGV("AudioCommandThread() processing update spatializer tracks");
2188 svc = mService.promote();
2189 if (svc == 0) {
2190 break;
2191 }
2192 mLock.unlock();
2193 svc->doOnUpdateActiveSpatializerTracks();
2194 mLock.lock();
2195 } break;
2196
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002197 case VOL_RANGE_INIT_REQUEST: {
2198 ALOGV("AudioCommandThread() processing volume range init request");
2199 svc = mService.promote();
2200 if (svc == 0) {
2201 break;
2202 }
2203 mLock.unlock();
2204 svc->doOnVolumeRangeInitRequest();
2205 mLock.lock();
2206 } break;
2207
Mathias Agopian65ab4712010-07-14 17:59:35 -07002208 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002209 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002210 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002211 {
2212 Mutex::Autolock _l(command->mLock);
2213 if (command->mWaitStatus) {
2214 command->mWaitStatus = false;
2215 command->mCond.signal();
2216 }
2217 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002218 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002219 // release mLock before releasing strong reference on the service as
2220 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2221 // acquires mLock.
2222 mLock.unlock();
2223 svc.clear();
2224 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002225 } else {
2226 waitTime = mAudioCommands[0]->mTime - curTime;
2227 break;
2228 }
2229 }
Zach Janga754b4f2015-10-27 01:29:34 +00002230
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002231 // release delayed commands wake lock as many times as we made the queue is
2232 // empty during popping.
2233 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002234 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002235 }
2236
2237 // At this stage we have either an empty command queue or the first command in the queue
2238 // has a finite delay. So unless we are exiting it is safe to wait.
2239 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002240 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002241 if (waitTime == -1) {
2242 mWaitWorkCV.wait(mLock);
2243 } else {
2244 mWaitWorkCV.waitRelative(mLock, waitTime);
2245 }
Eric Laurent59a89232014-06-08 14:14:17 -07002246 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002247 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002248 // release delayed commands wake lock before quitting
2249 if (!mAudioCommands.isEmpty()) {
2250 release_wake_lock(mName.string());
2251 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002252 mLock.unlock();
2253 return false;
2254}
2255
2256status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2257{
2258 const size_t SIZE = 256;
2259 char buffer[SIZE];
2260 String8 result;
2261
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002262 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002263 if (!locked) {
2264 String8 result2(kCmdDeadlockedString);
2265 write(fd, result2.string(), result2.size());
2266 }
2267
2268 snprintf(buffer, SIZE, "- Commands:\n");
2269 result = String8(buffer);
2270 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002271 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002272 mAudioCommands[i]->dump(buffer, SIZE);
2273 result.append(buffer);
2274 }
2275 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002276 if (mLastCommand != 0) {
2277 mLastCommand->dump(buffer, SIZE);
2278 result.append(buffer);
2279 } else {
2280 result.append(" none\n");
2281 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002282
2283 write(fd, result.string(), result.size());
2284
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002285 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002286
2287 return NO_ERROR;
2288}
2289
Glenn Kastenfff6d712012-01-12 16:38:12 -08002290status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002291 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002292 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002293 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002294{
Eric Laurent0ede8922014-05-09 18:04:42 -07002295 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002296 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002297 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002298 data->mStream = stream;
2299 data->mVolume = volume;
2300 data->mIO = output;
2301 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002302 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002303 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002304 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002305 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002306}
2307
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002308status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002309 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002310 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002311{
Eric Laurent0ede8922014-05-09 18:04:42 -07002312 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002313 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002314 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002315 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002316 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002317 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002318 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002319 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002320 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002321 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002322}
2323
2324status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2325{
Eric Laurent0ede8922014-05-09 18:04:42 -07002326 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002327 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002328 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002329 data->mVolume = volume;
2330 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002331 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002332 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002333 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002334}
2335
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002336void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2337 audio_session_t sessionId,
2338 bool suspended)
2339{
2340 sp<AudioCommand> command = new AudioCommand();
2341 command->mCommand = SET_EFFECT_SUSPENDED;
2342 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2343 data->mEffectId = effectId;
2344 data->mSessionId = sessionId;
2345 data->mSuspended = suspended;
2346 command->mParam = data;
2347 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2348 effectId, sessionId, suspended);
2349 sendCommand(command);
2350}
2351
2352
Eric Laurentd7fe0862018-07-14 16:48:01 -07002353void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002354{
Eric Laurent0ede8922014-05-09 18:04:42 -07002355 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002356 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002357 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002358 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002359 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002360 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002361 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002362}
2363
Eric Laurentd7fe0862018-07-14 16:48:01 -07002364void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002365{
Eric Laurent0ede8922014-05-09 18:04:42 -07002366 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002367 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002368 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002369 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002370 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002371 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002372 sendCommand(command);
2373}
2374
Eric Laurent951f4552014-05-20 10:48:17 -07002375status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2376 const struct audio_patch *patch,
2377 audio_patch_handle_t *handle,
2378 int delayMs)
2379{
2380 status_t status = NO_ERROR;
2381
2382 sp<AudioCommand> command = new AudioCommand();
2383 command->mCommand = CREATE_AUDIO_PATCH;
2384 CreateAudioPatchData *data = new CreateAudioPatchData();
2385 data->mPatch = *patch;
2386 data->mHandle = *handle;
2387 command->mParam = data;
2388 command->mWaitStatus = true;
2389 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2390 status = sendCommand(command, delayMs);
2391 if (status == NO_ERROR) {
2392 *handle = data->mHandle;
2393 }
2394 return status;
2395}
2396
2397status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2398 int delayMs)
2399{
2400 sp<AudioCommand> command = new AudioCommand();
2401 command->mCommand = RELEASE_AUDIO_PATCH;
2402 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2403 data->mHandle = handle;
2404 command->mParam = data;
2405 command->mWaitStatus = true;
2406 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2407 return sendCommand(command, delayMs);
2408}
2409
Eric Laurentb52c1522014-05-20 11:27:36 -07002410void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2411{
2412 sp<AudioCommand> command = new AudioCommand();
2413 command->mCommand = UPDATE_AUDIOPORT_LIST;
2414 ALOGV("AudioCommandThread() adding update audio port list");
2415 sendCommand(command);
2416}
2417
Eric Laurented726cc2021-07-01 14:26:41 +02002418void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2419{
2420 sp<AudioCommand> command = new AudioCommand();
2421 command->mCommand = UPDATE_UID_STATES;
2422 ALOGV("AudioCommandThread() adding update UID states");
2423 sendCommand(command);
2424}
2425
Eric Laurentb52c1522014-05-20 11:27:36 -07002426void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2427{
2428 sp<AudioCommand>command = new AudioCommand();
2429 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2430 ALOGV("AudioCommandThread() adding update audio patch list");
2431 sendCommand(command);
2432}
2433
François Gaffiecfe17322018-11-07 13:41:29 +01002434void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2435 int flags)
2436{
2437 sp<AudioCommand>command = new AudioCommand();
2438 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2439 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2440 data->mGroup = group;
2441 data->mFlags = flags;
2442 command->mParam = data;
2443 ALOGV("AudioCommandThread() adding audio volume group changed");
2444 sendCommand(command);
2445}
2446
Eric Laurente1715a42014-05-20 11:30:42 -07002447status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2448 const struct audio_port_config *config, int delayMs)
2449{
2450 sp<AudioCommand> command = new AudioCommand();
2451 command->mCommand = SET_AUDIOPORT_CONFIG;
2452 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2453 data->mConfig = *config;
2454 command->mParam = data;
2455 command->mWaitStatus = true;
2456 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2457 return sendCommand(command, delayMs);
2458}
2459
Jean-Michel Trivide801052015-04-14 19:10:14 -07002460void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002461 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002462{
2463 sp<AudioCommand> command = new AudioCommand();
2464 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2465 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2466 data->mRegId = regId;
2467 data->mState = state;
2468 command->mParam = data;
2469 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2470 regId.string(), state);
2471 sendCommand(command);
2472}
2473
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002474void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002475 int event,
2476 const record_client_info_t *clientInfo,
2477 const audio_config_base_t *clientConfig,
2478 std::vector<effect_descriptor_t> clientEffects,
2479 const audio_config_base_t *deviceConfig,
2480 std::vector<effect_descriptor_t> effects,
2481 audio_patch_handle_t patchHandle,
2482 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002483{
2484 sp<AudioCommand>command = new AudioCommand();
2485 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2486 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2487 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002488 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002489 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002490 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002491 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002492 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002493 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002494 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002495 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002496 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2497 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002498 sendCommand(command);
2499}
2500
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002501void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2502{
2503 sp<AudioCommand> command = new AudioCommand();
2504 command->mCommand = AUDIO_MODULES_UPDATE;
2505 sendCommand(command);
2506}
2507
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002508void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2509{
2510 sp<AudioCommand>command = new AudioCommand();
2511 command->mCommand = ROUTING_UPDATED;
2512 ALOGV("AudioCommandThread() adding routing update");
2513 sendCommand(command);
2514}
2515
Eric Laurent81dd0f52021-07-05 11:54:40 +02002516void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2517{
2518 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002519 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002520 ALOGV("AudioCommandThread() adding check spatializer");
2521 sendCommand(command);
2522}
2523
Eric Laurent15903592022-02-24 20:44:36 +01002524void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2525{
2526 sp<AudioCommand>command = new AudioCommand();
2527 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2528 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2529 sendCommand(command);
2530}
2531
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002532void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2533{
2534 sp<AudioCommand>command = new AudioCommand();
2535 command->mCommand = VOL_RANGE_INIT_REQUEST;
2536 ALOGV("AudioCommandThread() adding volume range init request");
2537 sendCommand(command);
2538}
2539
Eric Laurent0ede8922014-05-09 18:04:42 -07002540status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2541{
2542 {
2543 Mutex::Autolock _l(mLock);
2544 insertCommand_l(command, delayMs);
2545 mWaitWorkCV.signal();
2546 }
2547 Mutex::Autolock _l(command->mLock);
2548 while (command->mWaitStatus) {
2549 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2550 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2551 command->mStatus = TIMED_OUT;
2552 command->mWaitStatus = false;
2553 }
2554 }
2555 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002556}
2557
Mathias Agopian65ab4712010-07-14 17:59:35 -07002558// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002559void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002560{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002561 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002562 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002563 command->mTime = systemTime() + milliseconds(delayMs);
2564
2565 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002566 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002567 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2568 }
2569
2570 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002571 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002572 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002573 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2574 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002575
2576 // create audio patch or release audio patch commands are equivalent
2577 // with regard to filtering
2578 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2579 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2580 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2581 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2582 continue;
2583 }
2584 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002585
2586 switch (command->mCommand) {
2587 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002588 ParametersData *data = (ParametersData *)command->mParam.get();
2589 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002590 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002591 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002592 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002593 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2594 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2595 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002596 String8 key;
2597 String8 value;
2598 param.getAt(j, key, value);
2599 for (size_t k = 0; k < param2.size(); k++) {
2600 String8 key2;
2601 String8 value2;
2602 param2.getAt(k, key2, value2);
2603 if (key2 == key) {
2604 param2.remove(key2);
2605 ALOGV("Filtering out parameter %s", key2.string());
2606 break;
2607 }
2608 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002609 }
2610 // if all keys have been filtered out, remove the command.
2611 // otherwise, update the key value pairs
2612 if (param2.size() == 0) {
2613 removedCommands.add(command2);
2614 } else {
2615 data2->mKeyValuePairs = param2.toString();
2616 }
Eric Laurent21e54562013-09-23 12:08:05 -07002617 command->mTime = command2->mTime;
2618 // force delayMs to non 0 so that code below does not request to wait for
2619 // command status as the command is now delayed
2620 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002621 } break;
2622
2623 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002624 VolumeData *data = (VolumeData *)command->mParam.get();
2625 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002626 if (data->mIO != data2->mIO) break;
2627 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002628 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002629 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002630 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002631 command->mTime = command2->mTime;
2632 // force delayMs to non 0 so that code below does not request to wait for
2633 // command status as the command is now delayed
2634 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002635 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002636
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002637 case SET_VOICE_VOLUME: {
2638 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2639 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2640 ALOGV("Filtering out voice volume command value %f replaced by %f",
2641 data2->mVolume, data->mVolume);
2642 removedCommands.add(command2);
2643 command->mTime = command2->mTime;
2644 // force delayMs to non 0 so that code below does not request to wait for
2645 // command status as the command is now delayed
2646 delayMs = 1;
2647 } break;
2648
Eric Laurente45b48a2014-09-04 16:40:57 -07002649 case CREATE_AUDIO_PATCH:
2650 case RELEASE_AUDIO_PATCH: {
2651 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002652 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002653 if (command->mCommand == CREATE_AUDIO_PATCH) {
2654 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002655 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002656 } else {
2657 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002658 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002659 }
2660 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002661 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002662 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2663 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002664 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002665 } else {
2666 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002667 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002668 }
2669 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002670 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2671 same output. */
2672 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2673 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2674 bool isOutputDiff = false;
2675 if (patch.num_sources == patch2.num_sources) {
2676 for (unsigned count = 0; count < patch.num_sources; count++) {
2677 if (patch.sources[count].id != patch2.sources[count].id) {
2678 isOutputDiff = true;
2679 break;
2680 }
2681 }
2682 if (isOutputDiff)
2683 break;
2684 }
2685 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002686 ALOGV("Filtering out %s audio patch command for handle %d",
2687 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2688 removedCommands.add(command2);
2689 command->mTime = command2->mTime;
2690 // force delayMs to non 0 so that code below does not request to wait for
2691 // command status as the command is now delayed
2692 delayMs = 1;
2693 } break;
2694
Jean-Michel Trivide801052015-04-14 19:10:14 -07002695 case DYN_POLICY_MIX_STATE_UPDATE: {
2696
2697 } break;
2698
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002699 case RECORDING_CONFIGURATION_UPDATE: {
2700
2701 } break;
2702
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002703 case ROUTING_UPDATED: {
2704
2705 } break;
2706
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002707 case VOL_RANGE_INIT_REQUEST: {
2708 // command may come from different requests, do not filter
2709 } break;
2710
Mathias Agopian65ab4712010-07-14 17:59:35 -07002711 default:
2712 break;
2713 }
2714 }
2715
2716 // remove filtered commands
2717 for (size_t j = 0; j < removedCommands.size(); j++) {
2718 // removed commands always have time stamps greater than current command
2719 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002720 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002721 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002722 mAudioCommands.removeAt(k);
2723 break;
2724 }
2725 }
2726 }
2727 removedCommands.clear();
2728
Eric Laurentaa79bef2015-01-15 14:33:51 -08002729 // Disable wait for status if delay is not 0.
2730 // Except for create audio patch command because the returned patch handle
2731 // is needed by audio policy manager
2732 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002733 command->mWaitStatus = false;
2734 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002735
Mathias Agopian65ab4712010-07-14 17:59:35 -07002736 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002737 ALOGV("inserting command: %d at index %zd, num commands %zu",
2738 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002739 mAudioCommands.insertAt(command, i + 1);
2740}
2741
2742void AudioPolicyService::AudioCommandThread::exit()
2743{
Steve Block3856b092011-10-20 11:56:00 +01002744 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002745 {
2746 AutoMutex _l(mLock);
2747 requestExit();
2748 mWaitWorkCV.signal();
2749 }
Zach Janga754b4f2015-10-27 01:29:34 +00002750 // Note that we can call it from the thread loop if all other references have been released
2751 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002752 requestExitAndWait();
2753}
2754
2755void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2756{
2757 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2758 mCommand,
2759 (int)ns2s(mTime),
2760 (int)ns2ms(mTime)%1000,
2761 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002762 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002763}
2764
Dima Zavinfce7a472011-04-19 22:30:36 -07002765/******* helpers for the service_ops callbacks defined below *********/
2766void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2767 const char *keyValuePairs,
2768 int delayMs)
2769{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002770 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002771 delayMs);
2772}
2773
2774int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2775 float volume,
2776 audio_io_handle_t output,
2777 int delayMs)
2778{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002779 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002780 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002781}
2782
Dima Zavinfce7a472011-04-19 22:30:36 -07002783int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2784{
2785 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2786}
2787
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002788void AudioPolicyService::setEffectSuspended(int effectId,
2789 audio_session_t sessionId,
2790 bool suspended)
2791{
2792 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2793}
2794
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002795Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002796{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002797 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002798 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002799}
2800
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002801
Dima Zavinfce7a472011-04-19 22:30:36 -07002802extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002803audio_module_handle_t aps_load_hw_module(void *service __unused,
2804 const char *name);
2805audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002806 audio_devices_t *pDevices,
2807 uint32_t *pSamplingRate,
2808 audio_format_t *pFormat,
2809 audio_channel_mask_t *pChannelMask,
2810 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002811 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002812
Eric Laurent2d388ec2014-03-07 13:25:54 -08002813audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002814 audio_module_handle_t module,
2815 audio_devices_t *pDevices,
2816 uint32_t *pSamplingRate,
2817 audio_format_t *pFormat,
2818 audio_channel_mask_t *pChannelMask,
2819 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002820 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002821 const audio_offload_info_t *offloadInfo);
2822audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002823 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002824 audio_io_handle_t output2);
2825int aps_close_output(void *service __unused, audio_io_handle_t output);
2826int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2827int aps_restore_output(void *service __unused, audio_io_handle_t output);
2828audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002829 audio_devices_t *pDevices,
2830 uint32_t *pSamplingRate,
2831 audio_format_t *pFormat,
2832 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002833 audio_in_acoustics_t acoustics __unused);
2834audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002835 audio_module_handle_t module,
2836 audio_devices_t *pDevices,
2837 uint32_t *pSamplingRate,
2838 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002839 audio_channel_mask_t *pChannelMask);
2840int aps_close_input(void *service __unused, audio_io_handle_t input);
2841int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002842int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002843 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002844 audio_io_handle_t dst_output);
2845char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2846 const char *keys);
2847void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2848 const char *kv_pairs, int delay_ms);
2849int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002850 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002851 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002852int aps_set_voice_volume(void *service, float volume, int delay_ms);
2853};
Dima Zavinfce7a472011-04-19 22:30:36 -07002854
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002855} // namespace android