blob: 70349c2832f762292eadaa10e94959ee79ab157c [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) {
Andy Hung225aef62022-12-06 16:33:20 -0800205 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530206}
207
208void AudioPolicyService::loadAudioPolicyManager()
209{
210 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
211 if (mLibraryHandle != nullptr) {
212 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
213 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
214 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
215 const char *lastError = dlerror();
216 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
217 __func__, lastError != nullptr ? lastError : "no error");
218
219 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
220 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
221 lastError = dlerror();
222 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
223 __func__, lastError != nullptr ? lastError : "no error");
224 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
225 unloadAudioPolicyManager();
226 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
227 }
228 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700229}
230
231void AudioPolicyService::onFirstRef()
232{
Andy Hungd47aca22022-03-15 11:50:51 -0700233 // Log an AudioPolicy "constructor" mediametrics event on first ref.
234 // This records the time it takes to load the audio modules and devices.
235 mediametrics::Defer defer([beginNs = systemTime()] {
236 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
237 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
238 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
239 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700240 {
241 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800242
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700243 // start audio commands thread
244 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
245 // start output activity command thread
246 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700247
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700248 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530249
250 loadAudioPolicyManager();
251 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700252 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200253
bryant_liuba2b4392014-06-11 16:49:30 +0800254 // load audio processing modules
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000255 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
256 sp<UidPolicy> uidPolicy = new UidPolicy(this);
257 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700258 {
259 Mutex::Autolock _l(mLock);
260 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000261 mUidPolicy = uidPolicy;
262 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700263 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000264 uidPolicy->registerSelf();
265 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200266
Eric Laurent81dd0f52021-07-05 11:54:40 +0200267 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200268 if (mAudioPolicyManager != nullptr) {
269 Mutex::Autolock _l(mLock);
270 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
271 AudioDeviceTypeAddrVector devices;
272 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
273 if (hasSpatializer) {
274 mSpatializer = Spatializer::create(this);
275 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700276 if (mSpatializer == nullptr) {
277 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
278 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
279 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
280 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200281 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200282 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700283}
284
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530285void AudioPolicyService::unloadAudioPolicyManager()
286{
287 ALOGV("%s ", __func__);
288 if (mLibraryHandle != nullptr) {
289 dlclose(mLibraryHandle);
290 }
291 mLibraryHandle = nullptr;
292 mCreateAudioPolicyManager = nullptr;
293 mDestroyAudioPolicyManager = nullptr;
294}
295
Mathias Agopian65ab4712010-07-14 17:59:35 -0700296AudioPolicyService::~AudioPolicyService()
297{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700298 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700299 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700300
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530301 mDestroyAudioPolicyManager(mAudioPolicyManager);
302 unloadAudioPolicyManager();
303
Eric Laurentdce54a12014-03-10 12:19:46 -0700304 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700305
306 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800307 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800308
309 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800310 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000311
312 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800313 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700314}
315
316// A notification client is always registered by AudioSystem when the client process
317// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800318Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700319{
Eric Laurent12590252015-08-21 18:40:20 -0700320 if (client == 0) {
321 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800322 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700323 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800324 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700325
326 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800327 pid_t pid = IPCThreadState::self()->getCallingPid();
328 int64_t token = ((int64_t)uid<<32) | pid;
329
330 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700331 sp<NotificationClient> notificationClient = new NotificationClient(this,
332 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800333 uid,
334 pid);
335 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700336
luochaojiang908c7d72018-06-21 14:58:04 +0800337 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700338
Marco Nelissenf8880202014-11-14 07:58:25 -0800339 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700340 binder->linkToDeath(notificationClient);
341 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800342 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700343}
344
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800345Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700346{
347 Mutex::Autolock _l(mNotificationClientsLock);
348
349 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800350 pid_t pid = IPCThreadState::self()->getCallingPid();
351 int64_t token = ((int64_t)uid<<32) | pid;
352
353 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800354 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700355 }
luochaojiang908c7d72018-06-21 14:58:04 +0800356 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800357 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700358}
359
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800360Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100361{
362 Mutex::Autolock _l(mNotificationClientsLock);
363
364 uid_t uid = IPCThreadState::self()->getCallingUid();
365 pid_t pid = IPCThreadState::self()->getCallingPid();
366 int64_t token = ((int64_t)uid<<32) | pid;
367
368 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800369 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100370 }
371 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800372 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100373}
374
Eric Laurentb52c1522014-05-20 11:27:36 -0700375// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800376void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700377{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000378 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800379 {
380 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800381 int64_t token = ((int64_t)uid<<32) | pid;
382 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800383 for (size_t i = 0; i < mNotificationClients.size(); i++) {
384 if (mNotificationClients.valueAt(i)->uid() == uid) {
385 hasSameUid = true;
386 break;
387 }
388 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000389 }
390 {
391 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800392 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700393 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700394 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700395 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800396 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700397}
398
399void AudioPolicyService::onAudioPortListUpdate()
400{
401 mOutputCommandThread->updateAudioPortListCommand();
402}
403
404void AudioPolicyService::doOnAudioPortListUpdate()
405{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800406 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700407 for (size_t i = 0; i < mNotificationClients.size(); i++) {
408 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
409 }
410}
411
412void AudioPolicyService::onAudioPatchListUpdate()
413{
414 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700415}
416
Eric Laurentb52c1522014-05-20 11:27:36 -0700417void AudioPolicyService::doOnAudioPatchListUpdate()
418{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800419 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700420 for (size_t i = 0; i < mNotificationClients.size(); i++) {
421 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
422 }
423}
424
François Gaffiecfe17322018-11-07 13:41:29 +0100425void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
426{
427 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
428}
429
430void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
431{
432 Mutex::Autolock _l(mNotificationClientsLock);
433 for (size_t i = 0; i < mNotificationClients.size(); i++) {
434 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
435 }
436}
437
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700438void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700439{
440 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
441 regId.string(), state);
442 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
443}
444
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700445void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700446{
447 Mutex::Autolock _l(mNotificationClientsLock);
448 for (size_t i = 0; i < mNotificationClients.size(); i++) {
449 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
450 }
451}
452
Eric Laurenta9f86652018-11-28 17:23:11 -0800453void AudioPolicyService::onRecordingConfigurationUpdate(
454 int event,
455 const record_client_info_t *clientInfo,
456 const audio_config_base_t *clientConfig,
457 std::vector<effect_descriptor_t> clientEffects,
458 const audio_config_base_t *deviceConfig,
459 std::vector<effect_descriptor_t> effects,
460 audio_patch_handle_t patchHandle,
461 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800462{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800463 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800464 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800465}
466
Eric Laurenta9f86652018-11-28 17:23:11 -0800467void AudioPolicyService::doOnRecordingConfigurationUpdate(
468 int event,
469 const record_client_info_t *clientInfo,
470 const audio_config_base_t *clientConfig,
471 std::vector<effect_descriptor_t> clientEffects,
472 const audio_config_base_t *deviceConfig,
473 std::vector<effect_descriptor_t> effects,
474 audio_patch_handle_t patchHandle,
475 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800476{
477 Mutex::Autolock _l(mNotificationClientsLock);
478 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800479 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800480 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800481 }
482}
483
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700484void AudioPolicyService::onRoutingUpdated()
485{
486 mOutputCommandThread->routingChangedCommand();
487}
488
489void AudioPolicyService::doOnRoutingUpdated()
490{
491 Mutex::Autolock _l(mNotificationClientsLock);
492 for (size_t i = 0; i < mNotificationClients.size(); i++) {
493 mNotificationClients.valueAt(i)->onRoutingUpdated();
494 }
495}
496
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000497void AudioPolicyService::onVolumeRangeInitRequest()
498{
499 mOutputCommandThread->volRangeInitReqCommand();
500}
501
502void AudioPolicyService::doOnVolumeRangeInitRequest()
503{
504 Mutex::Autolock _l(mNotificationClientsLock);
505 for (size_t i = 0; i < mNotificationClients.size(); i++) {
506 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
507 }
508}
509
Eric Laurent81dd0f52021-07-05 11:54:40 +0200510void AudioPolicyService::onCheckSpatializer()
511{
512 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200513 onCheckSpatializer_l();
514}
515
516void AudioPolicyService::onCheckSpatializer_l()
517{
518 if (mSpatializer != nullptr) {
519 mOutputCommandThread->checkSpatializerCommand();
520 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200521}
522
523void AudioPolicyService::doOnCheckSpatializer()
524{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200525 ALOGV("%s mSpatializer %p level %d",
526 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200527
Eric Laurent39095982021-08-24 18:29:27 +0200528 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200529 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200530 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
531 audio_io_handle_t currentOutput = mSpatializer->getOutput();
532 audio_io_handle_t newOutput;
533 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
534 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200535
536 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200537 status_t status =
538 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100539 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
540 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200541 if (status == NO_ERROR && currentOutput == newOutput) {
542 return;
543 }
Eric Laurent15903592022-02-24 20:44:36 +0100544 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200545 mLock.unlock();
546 // It is OK to call detachOutput() is none is already attached.
547 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200548 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
549 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200550 }
Eric Laurent39095982021-08-24 18:29:27 +0200551 mLock.lock();
552 if (status != NO_ERROR) {
553 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
554 }
555 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
556 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200557 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200558
Eric Laurent39095982021-08-24 18:29:27 +0200559 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200560 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200561 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200562 }
563 }
564 }
565}
566
Eric Laurent11094172022-04-05 18:27:42 +0200567size_t AudioPolicyService::countActiveClientsOnOutput_l(
568 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100569 size_t count = 0;
570 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
571 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200572 if (client->io == output && client->active
573 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100574 count++;
575 }
576 }
577 return count;
578}
579
580void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
581 if (mSpatializer == nullptr) {
582 return;
583 }
584 mOutputCommandThread->updateActiveSpatializerTracksCommand();
585}
586
587void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
588{
Eric Laurent21270b62022-07-04 15:11:29 +0200589 if (mSpatializer == nullptr) {
590 return;
591 }
592 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200593 size_t activeClients;
594 {
595 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200596 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100597 }
Eric Laurent21270b62022-07-04 15:11:29 +0200598 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100599}
600
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800601status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
602 audio_patch_handle_t *handle,
603 int delayMs)
604{
605 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
606}
607
608status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
609 int delayMs)
610{
611 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
612}
613
Eric Laurente1715a42014-05-20 11:30:42 -0700614status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
615 int delayMs)
616{
617 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
618}
619
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800620AudioPolicyService::NotificationClient::NotificationClient(
621 const sp<AudioPolicyService>& service,
622 const sp<media::IAudioPolicyServiceClient>& client,
623 uid_t uid,
624 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800625 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100626 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700627{
628}
629
630AudioPolicyService::NotificationClient::~NotificationClient()
631{
632}
633
634void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
635{
636 sp<NotificationClient> keep(this);
637 sp<AudioPolicyService> service = mService.promote();
638 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800639 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700640 }
641}
642
643void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
644{
Eric Laurente8726fe2015-06-26 09:39:24 -0700645 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700646 mAudioPolicyServiceClient->onAudioPortListUpdate();
647 }
648}
649
650void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
651{
Eric Laurente8726fe2015-06-26 09:39:24 -0700652 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700653 mAudioPolicyServiceClient->onAudioPatchListUpdate();
654 }
655}
Eric Laurent57dae992011-07-24 13:36:09 -0700656
Pattydd807582021-11-04 21:01:03 +0800657void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100658 int flags)
659{
660 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
661 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
662 }
663}
664
665
Jean-Michel Trivide801052015-04-14 19:10:14 -0700666void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700667 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700668{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700669 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800670 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
671 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800672 }
673}
674
675void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800676 int event,
677 const record_client_info_t *clientInfo,
678 const audio_config_base_t *clientConfig,
679 std::vector<effect_descriptor_t> clientEffects,
680 const audio_config_base_t *deviceConfig,
681 std::vector<effect_descriptor_t> effects,
682 audio_patch_handle_t patchHandle,
683 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800684{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700685 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800686 status_t status = [&]() -> status_t {
687 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
688 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
689 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700690 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700691 legacy2aidl_audio_config_base_t_AudioConfigBase(
692 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800693 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
694 convertContainer<std::vector<media::EffectDescriptor>>(
695 clientEffects,
696 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700697 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700698 legacy2aidl_audio_config_base_t_AudioConfigBase(
699 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800700 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
701 convertContainer<std::vector<media::EffectDescriptor>>(
702 effects,
703 legacy2aidl_effect_descriptor_t_EffectDescriptor));
704 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
705 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700706 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
707 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800708 return aidl_utils::statusTFromBinderStatus(
709 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
710 clientInfoAidl,
711 clientConfigAidl,
712 clientEffectsAidl,
713 deviceConfigAidl,
714 effectsAidl,
715 patchHandleAidl,
716 sourceAidl));
717 }();
718 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700719 }
720}
721
Eric Laurente8726fe2015-06-26 09:39:24 -0700722void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
723{
724 mAudioPortCallbacksEnabled = enabled;
725}
726
François Gaffiecfe17322018-11-07 13:41:29 +0100727void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
728{
729 mAudioVolumeGroupCallbacksEnabled = enabled;
730}
Eric Laurente8726fe2015-06-26 09:39:24 -0700731
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700732void AudioPolicyService::NotificationClient::onRoutingUpdated()
733{
734 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
735 mAudioPolicyServiceClient->onRoutingUpdated();
736 }
737}
738
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000739void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
740{
741 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
742 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
743 }
744}
745
Mathias Agopian65ab4712010-07-14 17:59:35 -0700746void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700747 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700748 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700749}
750
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000751static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700752{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000753 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
754}
755
756static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
757{
758 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700759}
760
761status_t AudioPolicyService::dumpInternals(int fd)
762{
763 const size_t SIZE = 256;
764 char buffer[SIZE];
765 String8 result;
766
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000767 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800768 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000769 std::stringstream msg;
770 size_t i = 0;
771 for (auto usage : mSupportedSystemUsages) {
772 if (i++ != 0) msg << ", ";
773 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
774 msg << strUsage;
775 } else {
776 msg << usage << " (unknown)";
777 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800778 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000779 if (i == 0) {
780 msg << "None";
781 }
782 msg << std::endl;
783 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800784
Mathias Agopian65ab4712010-07-14 17:59:35 -0700785 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800786
787 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700788 return NO_ERROR;
789}
790
Eric Laurente8c8b432018-10-17 10:08:02 -0700791void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800792{
Eric Laurente8c8b432018-10-17 10:08:02 -0700793 Mutex::Autolock _l(mLock);
794 updateUidStates_l();
795}
796
797void AudioPolicyService::updateUidStates_l()
798{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800799// Go over all active clients and allow capture (does not force silence) in the
800// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800801// The client is in the active assistant list
802// AND is TOP
803// AND an accessibility service is TOP
804// AND source is either VOICE_RECOGNITION OR HOTWORD
805// OR there is no active privacy sensitive capture or call
806// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
807// AND source is VOICE_RECOGNITION OR HOTWORD
808// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800809// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700810// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800811// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800812// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800813// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
814// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800815// OR The client is an accessibility service
816// AND Is on TOP
817// AND the source is VOICE_RECOGNITION or HOTWORD
818// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700819// AND there is no active privacy sensitive capture or call
820// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800821// AND is on TOP
822// AND the source is VOICE_RECOGNITION or HOTWORD
823// OR the client source is virtual (remote submix, call audio TX or RX...)
824// OR the client source is HOTWORD
825// AND is on TOP
826// OR all active clients are using HOTWORD source
827// AND no call is active
828// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
829// OR the client is the current InputMethodService
830// AND a RTT call is active AND the source is VOICE_RECOGNITION
831// OR Any client
832// AND The assistant is not on TOP
833// AND is on TOP or latest started
834// AND there is no active privacy sensitive capture or call
835// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800836
Eric Laurent4e947da2019-10-17 15:24:06 -0700837
Eric Laurent4eb58f12018-12-07 16:41:02 -0800838 sp<AudioRecordClient> topActive;
839 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800840 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700841 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800842 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700843
Eric Laurenta46bedb2018-12-07 18:01:26 -0800844 nsecs_t topStartNs = 0;
845 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800846 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800847 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800848 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800849 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
850 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800851 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800852 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700853 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800854 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
855 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700856 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700857 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700858 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800859
Michael Groovercfd28302018-12-11 19:16:46 -0800860 // if Sensor Privacy is enabled then all recordings should be silenced.
861 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
862 silenceAllRecordings_l();
863 return;
864 }
865
Eric Laurente8c8b432018-10-17 10:08:02 -0700866 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
867 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000868 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
869 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800870 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700871 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800872 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700873
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700874 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700875 // clients which app is in IDLE state are not eligible for top active or
876 // latest active
877 if (appState == APP_STATE_IDLE) {
878 continue;
879 }
880
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700881 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700882 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800883 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700884 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700885 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800886 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800887 bool isPrivacySensitive =
888 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700889
Eric Laurentc21d5692020-02-25 10:24:36 -0800890 if (appState == APP_STATE_TOP) {
891 if (isPrivacySensitive) {
892 if (current->startTimeNs > topSensitiveStartNs) {
893 topSensitiveActive = current;
894 topSensitiveStartNs = current->startTimeNs;
895 }
896 } else {
897 if (current->startTimeNs > topStartNs) {
898 topActive = current;
899 topStartNs = current->startTimeNs;
900 }
901 }
902 if (isAssistant) {
903 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800904 if (isActiveAssistant) {
905 useActiveAssistantList = true;
906 } else if (!useActiveAssistantList) {
907 if (current->startTimeNs > latestAssistantStartNs) {
908 latestActiveAssistant = current;
909 latestAssistantStartNs = current->startTimeNs;
910 }
911 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800912 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800913 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800914 // Clients capturing for HOTWORD are not considered
915 // for latest active to avoid masking regular clients started before
916 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
917 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
918 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700919 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
920 // is marked latest sensitive active even if another app qualifies.
921 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700922 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700923 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700924 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000925 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700926 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700927 latestSensitiveActiveOrComm = current;
928 latestSensitiveStartNs = current->startTimeNs;
929 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800930 }
931 isSensitiveActive = true;
932 } else {
933 if (current->startTimeNs > latestStartNs) {
934 latestActive = current;
935 latestStartNs = current->startTimeNs;
936 }
937 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800938 }
939 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700940 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
941 onlyHotwordActive = false;
942 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100943 if (currentUid == mPhoneStateOwnerUid &&
944 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700945 isPhoneStateOwnerActive = true;
946 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800947 }
948
Eric Laurent1ff16a72019-03-14 18:35:04 -0700949 // if no active client with UI on Top, consider latest active as top
950 if (topActive == nullptr) {
951 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800952 topStartNs = latestStartNs;
953 }
954 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700955 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800956 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700957 } else if (latestSensitiveActiveOrComm != nullptr) {
958 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
959 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700960 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000961 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700962 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700963 topSensitiveActive = latestSensitiveActiveOrComm;
964 topSensitiveStartNs = latestSensitiveStartNs;
965 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800966 }
967
968 // If both privacy sensitive and regular capture are active:
969 // if the regular capture is privileged
970 // allow concurrency
971 // else
972 // favor the privacy sensitive case
973 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700974 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800975 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800976 }
977
978 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
979 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700980 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000981 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700982 if (!current->active) {
983 continue;
984 }
985
Eric Laurent4eb58f12018-12-07 16:41:02 -0800986 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700987 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000988 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700989 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000990 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800991 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
992 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -0800993
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000994 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700995 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000996 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -0700997 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -0700998 bool canCaptureCommunication = recordClient->canCaptureOutput
999 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001000 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001001 return !(isInCall && !canCaptureCall)
1002 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001003 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001004
1005 // By default allow capture if:
1006 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001007 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001008 // AND there is no active privacy sensitive capture or call
1009 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1010 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001011 && (isTopOrLatestActive || isTopOrLatestSensitive)
1012 && !(isSensitiveActive
Ricardo Correa57a37692020-03-23 17:27:25 -07001013 && !(isTopOrLatestSensitive || current->canCaptureOutput))
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 }
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001036 } else if (!(isSensitiveActive && !current->canCaptureOutput)
1037 && 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 }
1057 } else if (!(isSensitiveActive && !current->canCaptureOutput)
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
Ricardo Correa57a37692020-03-23 17:27:25 -07001072 && !(isSensitiveActive && !current->canCaptureOutput)
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() {
1736 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001737 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001738 continue;
1739 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001740 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1741 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001742 return true;
1743 }
1744 }
1745 return false;
1746}
1747
Eric Laurentb78763e2018-10-17 10:08:02 -07001748bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1749{
1750 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1751 return it != mA11yUids.end();
1752}
1753
Oscar Azucena829d90d2022-01-28 17:17:56 -08001754void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1755 mAssistantUids.clear();
1756 mAssistantUids = uids;
1757}
1758
1759bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1760{
1761 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1762 return it != mAssistantUids.end();
1763}
1764
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001765void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1766 mActiveAssistantUids = activeUids;
1767}
1768
1769bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1770{
1771 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1772 mActiveAssistantUids.end(), uid);
1773 return it != mActiveAssistantUids.end();
1774}
1775
Oscar Azucena829d90d2022-01-28 17:17:56 -08001776void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1777 const size_t SIZE = 256;
1778 char buffer[SIZE];
1779 String8 result;
1780 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1781 snprintf(buffer, SIZE, "\t%s: \n", title);
1782 result.append(buffer);
1783 int counter = 0;
1784 if (uids.empty()) {
1785 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1786 result.append(buffer);
1787 return;
1788 }
1789 for (const auto &uid : uids) {
1790 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1791 result.append(buffer);
1792 }
1793 };
1794
1795 snprintf(buffer, SIZE, "UID Policy:\n");
1796 result.append(buffer);
1797 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1798 result.append(buffer);
1799
1800 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001801 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001802
1803 appendUidsToResult("Accessibility UIDs", mA11yUids);
1804
1805 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1806 result.append(buffer);
1807
1808 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1809 result.append(buffer);
1810
1811 write(fd, result.string(), result.size());
1812}
1813
Michael Groovercfd28302018-12-11 19:16:46 -08001814// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1815void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1816 SensorPrivacyManager spm;
1817 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
Eric Laurent60aa4d02022-11-17 11:47:19 +01001818 (void)spm.addToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001819 spm.addSensorPrivacyListener(this);
1820}
1821
1822void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1823 SensorPrivacyManager spm;
1824 spm.removeSensorPrivacyListener(this);
Eric Laurent60aa4d02022-11-17 11:47:19 +01001825 spm.removeToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001826}
1827
1828bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1829 return mSensorPrivacyEnabled;
1830}
1831
Evan Seversond8dc6832022-01-27 10:47:03 -08001832binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1833 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001834 mSensorPrivacyEnabled = enabled;
1835 sp<AudioPolicyService> service = mService.promote();
1836 if (service != nullptr) {
1837 service->updateUidStates();
1838 }
1839 return binder::Status::ok();
1840}
1841
Eric Laurented726cc2021-07-01 14:26:41 +02001842// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1843
1844// static
1845sp<AudioPolicyService::OpRecordAudioMonitor>
1846AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1847 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1848 wp<AudioCommandThread> commandThread)
1849{
Eric Laurent987ce102021-07-05 12:11:51 +02001850 if (isAudioServerOrRootUid(attributionSource.uid)) {
1851 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001852 attributionSource.toString().c_str());
1853 return nullptr;
1854 }
1855
1856 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1857 ALOGD("not monitoring app op for uid %d and source %d",
1858 attributionSource.uid, attr.source);
1859 return nullptr;
1860 }
1861
1862 if (!attributionSource.packageName.has_value()
1863 || attributionSource.packageName.value().size() == 0) {
1864 return nullptr;
1865 }
1866 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1867}
1868
1869AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1870 const AttributionSourceState& attributionSource, int32_t appOp,
1871 wp<AudioCommandThread> commandThread) :
1872 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1873 mCommandThread(commandThread)
1874{
1875}
1876
1877AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1878{
1879 if (mOpCallback != 0) {
1880 mAppOpsManager.stopWatchingMode(mOpCallback);
1881 }
1882 mOpCallback.clear();
1883}
1884
1885void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1886{
1887 checkOp();
1888 mOpCallback = new RecordAudioOpCallback(this);
1889 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1890 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1891 // since it controls the mic permission for legacy apps.
1892 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1893 mAttributionSource.packageName.value_or(""))),
1894 mOpCallback);
1895}
1896
1897bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1898 return mHasOp.load();
1899}
1900
1901// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1902// is updated in AppOp callback and in onFirstRef()
1903// Note this method is never called (and never to be) for audio server / root track
1904// due to the UID in createIfNeeded(). As a result for those record track, it's:
1905// - not called from constructor,
1906// - not called from RecordAudioOpCallback because the callback is not installed in this case
1907void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1908{
1909 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1910 // since it controls the mic permission for legacy apps.
1911 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1912 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1913 mAttributionSource.packageName.value_or(""))));
1914 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1915 // verbose logging only log when appOp changed
1916 ALOGI_IF(hasIt != mHasOp.load(),
1917 "App op %d missing, %ssilencing record %s",
1918 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1919 mHasOp.store(hasIt);
1920
1921 if (updateUidStates) {
1922 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1923 if (commandThread != nullptr) {
1924 commandThread->updateUidStatesCommand();
1925 }
1926 }
1927}
1928
1929AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1930 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1931{ }
1932
1933void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1934 const String16& packageName __unused) {
1935 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1936 if (monitor != NULL) {
1937 if (op != monitor->getOp()) {
1938 return;
1939 }
1940 monitor->checkOp(true);
1941 }
1942}
1943
1944
Mathias Agopian65ab4712010-07-14 17:59:35 -07001945// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1946
Eric Laurentbfb1b832013-01-07 09:53:42 -08001947AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1948 const wp<AudioPolicyService>& service)
1949 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001950{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001951}
1952
1953
1954AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1955{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001956 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001957 release_wake_lock(mName.string());
1958 }
1959 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001960}
1961
1962void AudioPolicyService::AudioCommandThread::onFirstRef()
1963{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001964 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001965}
1966
1967bool AudioPolicyService::AudioCommandThread::threadLoop()
1968{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001969 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001970
1971 mLock.lock();
1972 while (!exitPending())
1973 {
Eric Laurent59a89232014-06-08 14:14:17 -07001974 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001975 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001976 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001977 nsecs_t curTime = systemTime();
1978 // commands are sorted by increasing time stamp: execute them from index 0 and up
1979 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001980 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001981 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001982 if (mAudioCommands.isEmpty()) {
1983 ++numTimesBecameEmpty;
1984 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001985 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001986
1987 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001988 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001989 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001990 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001991 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001992 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001993 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1994 data->mVolume,
1995 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07001996 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001997 }break;
1998 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001999 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002000 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2001 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002002 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002003 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002004 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002005 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002006 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002007 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002008 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002009 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002010 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002011 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002012 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002013 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002014 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002015 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002016 ALOGV("AudioCommandThread() processing stop output portId %d",
2017 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002018 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002019 if (svc == 0) {
2020 break;
2021 }
2022 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002023 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002024 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002025 }break;
2026 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002027 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002028 ALOGV("AudioCommandThread() processing release output portId %d",
2029 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002030 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002031 if (svc == 0) {
2032 break;
2033 }
2034 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002035 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002036 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002037 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002038 case CREATE_AUDIO_PATCH: {
2039 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2040 ALOGV("AudioCommandThread() processing create audio patch");
2041 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2042 if (af == 0) {
2043 command->mStatus = PERMISSION_DENIED;
2044 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002045 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002046 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002047 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002048 }
2049 } break;
2050 case RELEASE_AUDIO_PATCH: {
2051 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2052 ALOGV("AudioCommandThread() processing release audio patch");
2053 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2054 if (af == 0) {
2055 command->mStatus = PERMISSION_DENIED;
2056 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002057 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002058 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002059 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002060 }
2061 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002062 case UPDATE_AUDIOPORT_LIST: {
2063 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002064 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002065 if (svc == 0) {
2066 break;
2067 }
2068 mLock.unlock();
2069 svc->doOnAudioPortListUpdate();
2070 mLock.lock();
2071 }break;
2072 case UPDATE_AUDIOPATCH_LIST: {
2073 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002074 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002075 if (svc == 0) {
2076 break;
2077 }
2078 mLock.unlock();
2079 svc->doOnAudioPatchListUpdate();
2080 mLock.lock();
2081 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002082 case CHANGED_AUDIOVOLUMEGROUP: {
2083 AudioVolumeGroupData *data =
2084 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2085 ALOGV("AudioCommandThread() processing update audio volume group");
2086 svc = mService.promote();
2087 if (svc == 0) {
2088 break;
2089 }
2090 mLock.unlock();
2091 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2092 mLock.lock();
2093 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002094 case SET_AUDIOPORT_CONFIG: {
2095 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2096 ALOGV("AudioCommandThread() processing set port config");
2097 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2098 if (af == 0) {
2099 command->mStatus = PERMISSION_DENIED;
2100 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002101 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002102 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002103 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002104 }
2105 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002106 case DYN_POLICY_MIX_STATE_UPDATE: {
2107 DynPolicyMixStateUpdateData *data =
2108 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002109 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2110 data->mRegId.string(), data->mState);
2111 svc = mService.promote();
2112 if (svc == 0) {
2113 break;
2114 }
2115 mLock.unlock();
2116 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2117 mLock.lock();
2118 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002119 case RECORDING_CONFIGURATION_UPDATE: {
2120 RecordingConfigurationUpdateData *data =
2121 (RecordingConfigurationUpdateData *)command->mParam.get();
2122 ALOGV("AudioCommandThread() processing recording configuration update");
2123 svc = mService.promote();
2124 if (svc == 0) {
2125 break;
2126 }
2127 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002128 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002129 &data->mClientConfig, data->mClientEffects,
2130 &data->mDeviceConfig, data->mEffects,
2131 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002132 mLock.lock();
2133 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002134 case SET_EFFECT_SUSPENDED: {
2135 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2136 ALOGV("AudioCommandThread() processing set effect suspended");
2137 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2138 if (af != 0) {
2139 mLock.unlock();
2140 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2141 mLock.lock();
2142 }
2143 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002144 case AUDIO_MODULES_UPDATE: {
2145 ALOGV("AudioCommandThread() processing audio modules update");
2146 svc = mService.promote();
2147 if (svc == 0) {
2148 break;
2149 }
2150 mLock.unlock();
2151 svc->doOnNewAudioModulesAvailable();
2152 mLock.lock();
2153 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002154 case ROUTING_UPDATED: {
2155 ALOGV("AudioCommandThread() processing routing update");
2156 svc = mService.promote();
2157 if (svc == 0) {
2158 break;
2159 }
2160 mLock.unlock();
2161 svc->doOnRoutingUpdated();
2162 mLock.lock();
2163 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002164
Eric Laurented726cc2021-07-01 14:26:41 +02002165 case UPDATE_UID_STATES: {
2166 ALOGV("AudioCommandThread() processing updateUID states");
2167 svc = mService.promote();
2168 if (svc == 0) {
2169 break;
2170 }
2171 mLock.unlock();
2172 svc->updateUidStates();
2173 mLock.lock();
2174 } break;
2175
Eric Laurent15903592022-02-24 20:44:36 +01002176 case CHECK_SPATIALIZER_OUTPUT: {
2177 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002178 svc = mService.promote();
2179 if (svc == 0) {
2180 break;
2181 }
2182 mLock.unlock();
2183 svc->doOnCheckSpatializer();
2184 mLock.lock();
2185 } break;
2186
Eric Laurent15903592022-02-24 20:44:36 +01002187 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2188 ALOGV("AudioCommandThread() processing update spatializer tracks");
2189 svc = mService.promote();
2190 if (svc == 0) {
2191 break;
2192 }
2193 mLock.unlock();
2194 svc->doOnUpdateActiveSpatializerTracks();
2195 mLock.lock();
2196 } break;
2197
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002198 case VOL_RANGE_INIT_REQUEST: {
2199 ALOGV("AudioCommandThread() processing volume range init request");
2200 svc = mService.promote();
2201 if (svc == 0) {
2202 break;
2203 }
2204 mLock.unlock();
2205 svc->doOnVolumeRangeInitRequest();
2206 mLock.lock();
2207 } break;
2208
Mathias Agopian65ab4712010-07-14 17:59:35 -07002209 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002210 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002211 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002212 {
2213 Mutex::Autolock _l(command->mLock);
2214 if (command->mWaitStatus) {
2215 command->mWaitStatus = false;
2216 command->mCond.signal();
2217 }
2218 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002219 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002220 // release mLock before releasing strong reference on the service as
2221 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2222 // acquires mLock.
2223 mLock.unlock();
2224 svc.clear();
2225 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002226 } else {
2227 waitTime = mAudioCommands[0]->mTime - curTime;
2228 break;
2229 }
2230 }
Zach Janga754b4f2015-10-27 01:29:34 +00002231
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002232 // release delayed commands wake lock as many times as we made the queue is
2233 // empty during popping.
2234 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002235 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002236 }
2237
2238 // At this stage we have either an empty command queue or the first command in the queue
2239 // has a finite delay. So unless we are exiting it is safe to wait.
2240 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002241 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002242 if (waitTime == -1) {
2243 mWaitWorkCV.wait(mLock);
2244 } else {
2245 mWaitWorkCV.waitRelative(mLock, waitTime);
2246 }
Eric Laurent59a89232014-06-08 14:14:17 -07002247 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002248 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002249 // release delayed commands wake lock before quitting
2250 if (!mAudioCommands.isEmpty()) {
2251 release_wake_lock(mName.string());
2252 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002253 mLock.unlock();
2254 return false;
2255}
2256
2257status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2258{
2259 const size_t SIZE = 256;
2260 char buffer[SIZE];
2261 String8 result;
2262
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002263 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002264 if (!locked) {
2265 String8 result2(kCmdDeadlockedString);
2266 write(fd, result2.string(), result2.size());
2267 }
2268
2269 snprintf(buffer, SIZE, "- Commands:\n");
2270 result = String8(buffer);
2271 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002272 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002273 mAudioCommands[i]->dump(buffer, SIZE);
2274 result.append(buffer);
2275 }
2276 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002277 if (mLastCommand != 0) {
2278 mLastCommand->dump(buffer, SIZE);
2279 result.append(buffer);
2280 } else {
2281 result.append(" none\n");
2282 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002283
2284 write(fd, result.string(), result.size());
2285
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002286 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002287
2288 return NO_ERROR;
2289}
2290
Glenn Kastenfff6d712012-01-12 16:38:12 -08002291status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002292 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002293 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002294 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002295{
Eric Laurent0ede8922014-05-09 18:04:42 -07002296 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002297 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002298 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002299 data->mStream = stream;
2300 data->mVolume = volume;
2301 data->mIO = output;
2302 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002303 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002304 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002305 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002306 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002307}
2308
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002309status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002310 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002311 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002312{
Eric Laurent0ede8922014-05-09 18:04:42 -07002313 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002314 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002315 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002316 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002317 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002318 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002319 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002320 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002321 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002322 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002323}
2324
2325status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2326{
Eric Laurent0ede8922014-05-09 18:04:42 -07002327 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002328 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002329 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002330 data->mVolume = volume;
2331 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002332 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002333 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002334 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002335}
2336
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002337void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2338 audio_session_t sessionId,
2339 bool suspended)
2340{
2341 sp<AudioCommand> command = new AudioCommand();
2342 command->mCommand = SET_EFFECT_SUSPENDED;
2343 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2344 data->mEffectId = effectId;
2345 data->mSessionId = sessionId;
2346 data->mSuspended = suspended;
2347 command->mParam = data;
2348 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2349 effectId, sessionId, suspended);
2350 sendCommand(command);
2351}
2352
2353
Eric Laurentd7fe0862018-07-14 16:48:01 -07002354void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002355{
Eric Laurent0ede8922014-05-09 18:04:42 -07002356 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002357 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002358 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002359 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002360 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002361 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002362 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002363}
2364
Eric Laurentd7fe0862018-07-14 16:48:01 -07002365void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002366{
Eric Laurent0ede8922014-05-09 18:04:42 -07002367 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002368 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002369 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002370 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002371 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002372 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002373 sendCommand(command);
2374}
2375
Eric Laurent951f4552014-05-20 10:48:17 -07002376status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2377 const struct audio_patch *patch,
2378 audio_patch_handle_t *handle,
2379 int delayMs)
2380{
2381 status_t status = NO_ERROR;
2382
2383 sp<AudioCommand> command = new AudioCommand();
2384 command->mCommand = CREATE_AUDIO_PATCH;
2385 CreateAudioPatchData *data = new CreateAudioPatchData();
2386 data->mPatch = *patch;
2387 data->mHandle = *handle;
2388 command->mParam = data;
2389 command->mWaitStatus = true;
2390 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2391 status = sendCommand(command, delayMs);
2392 if (status == NO_ERROR) {
2393 *handle = data->mHandle;
2394 }
2395 return status;
2396}
2397
2398status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2399 int delayMs)
2400{
2401 sp<AudioCommand> command = new AudioCommand();
2402 command->mCommand = RELEASE_AUDIO_PATCH;
2403 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2404 data->mHandle = handle;
2405 command->mParam = data;
2406 command->mWaitStatus = true;
2407 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2408 return sendCommand(command, delayMs);
2409}
2410
Eric Laurentb52c1522014-05-20 11:27:36 -07002411void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2412{
2413 sp<AudioCommand> command = new AudioCommand();
2414 command->mCommand = UPDATE_AUDIOPORT_LIST;
2415 ALOGV("AudioCommandThread() adding update audio port list");
2416 sendCommand(command);
2417}
2418
Eric Laurented726cc2021-07-01 14:26:41 +02002419void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2420{
2421 sp<AudioCommand> command = new AudioCommand();
2422 command->mCommand = UPDATE_UID_STATES;
2423 ALOGV("AudioCommandThread() adding update UID states");
2424 sendCommand(command);
2425}
2426
Eric Laurentb52c1522014-05-20 11:27:36 -07002427void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2428{
2429 sp<AudioCommand>command = new AudioCommand();
2430 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2431 ALOGV("AudioCommandThread() adding update audio patch list");
2432 sendCommand(command);
2433}
2434
François Gaffiecfe17322018-11-07 13:41:29 +01002435void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2436 int flags)
2437{
2438 sp<AudioCommand>command = new AudioCommand();
2439 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2440 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2441 data->mGroup = group;
2442 data->mFlags = flags;
2443 command->mParam = data;
2444 ALOGV("AudioCommandThread() adding audio volume group changed");
2445 sendCommand(command);
2446}
2447
Eric Laurente1715a42014-05-20 11:30:42 -07002448status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2449 const struct audio_port_config *config, int delayMs)
2450{
2451 sp<AudioCommand> command = new AudioCommand();
2452 command->mCommand = SET_AUDIOPORT_CONFIG;
2453 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2454 data->mConfig = *config;
2455 command->mParam = data;
2456 command->mWaitStatus = true;
2457 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2458 return sendCommand(command, delayMs);
2459}
2460
Jean-Michel Trivide801052015-04-14 19:10:14 -07002461void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002462 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002463{
2464 sp<AudioCommand> command = new AudioCommand();
2465 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2466 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2467 data->mRegId = regId;
2468 data->mState = state;
2469 command->mParam = data;
2470 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2471 regId.string(), state);
2472 sendCommand(command);
2473}
2474
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002475void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002476 int event,
2477 const record_client_info_t *clientInfo,
2478 const audio_config_base_t *clientConfig,
2479 std::vector<effect_descriptor_t> clientEffects,
2480 const audio_config_base_t *deviceConfig,
2481 std::vector<effect_descriptor_t> effects,
2482 audio_patch_handle_t patchHandle,
2483 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002484{
2485 sp<AudioCommand>command = new AudioCommand();
2486 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2487 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2488 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002489 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002490 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002491 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002492 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002493 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002494 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002495 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002496 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002497 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2498 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002499 sendCommand(command);
2500}
2501
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002502void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2503{
2504 sp<AudioCommand> command = new AudioCommand();
2505 command->mCommand = AUDIO_MODULES_UPDATE;
2506 sendCommand(command);
2507}
2508
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002509void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2510{
2511 sp<AudioCommand>command = new AudioCommand();
2512 command->mCommand = ROUTING_UPDATED;
2513 ALOGV("AudioCommandThread() adding routing update");
2514 sendCommand(command);
2515}
2516
Eric Laurent81dd0f52021-07-05 11:54:40 +02002517void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2518{
2519 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002520 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002521 ALOGV("AudioCommandThread() adding check spatializer");
2522 sendCommand(command);
2523}
2524
Eric Laurent15903592022-02-24 20:44:36 +01002525void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2526{
2527 sp<AudioCommand>command = new AudioCommand();
2528 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2529 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2530 sendCommand(command);
2531}
2532
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002533void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2534{
2535 sp<AudioCommand>command = new AudioCommand();
2536 command->mCommand = VOL_RANGE_INIT_REQUEST;
2537 ALOGV("AudioCommandThread() adding volume range init request");
2538 sendCommand(command);
2539}
2540
Eric Laurent0ede8922014-05-09 18:04:42 -07002541status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2542{
2543 {
2544 Mutex::Autolock _l(mLock);
2545 insertCommand_l(command, delayMs);
2546 mWaitWorkCV.signal();
2547 }
2548 Mutex::Autolock _l(command->mLock);
2549 while (command->mWaitStatus) {
2550 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2551 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2552 command->mStatus = TIMED_OUT;
2553 command->mWaitStatus = false;
2554 }
2555 }
2556 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002557}
2558
Mathias Agopian65ab4712010-07-14 17:59:35 -07002559// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002560void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002561{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002562 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002563 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002564 command->mTime = systemTime() + milliseconds(delayMs);
2565
2566 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002567 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002568 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2569 }
2570
2571 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002572 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002573 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002574 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2575 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002576
2577 // create audio patch or release audio patch commands are equivalent
2578 // with regard to filtering
2579 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2580 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2581 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2582 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2583 continue;
2584 }
2585 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002586
2587 switch (command->mCommand) {
2588 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002589 ParametersData *data = (ParametersData *)command->mParam.get();
2590 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002591 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002592 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002593 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002594 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2595 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2596 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002597 String8 key;
2598 String8 value;
2599 param.getAt(j, key, value);
2600 for (size_t k = 0; k < param2.size(); k++) {
2601 String8 key2;
2602 String8 value2;
2603 param2.getAt(k, key2, value2);
2604 if (key2 == key) {
2605 param2.remove(key2);
2606 ALOGV("Filtering out parameter %s", key2.string());
2607 break;
2608 }
2609 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002610 }
2611 // if all keys have been filtered out, remove the command.
2612 // otherwise, update the key value pairs
2613 if (param2.size() == 0) {
2614 removedCommands.add(command2);
2615 } else {
2616 data2->mKeyValuePairs = param2.toString();
2617 }
Eric Laurent21e54562013-09-23 12:08:05 -07002618 command->mTime = command2->mTime;
2619 // force delayMs to non 0 so that code below does not request to wait for
2620 // command status as the command is now delayed
2621 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002622 } break;
2623
2624 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002625 VolumeData *data = (VolumeData *)command->mParam.get();
2626 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002627 if (data->mIO != data2->mIO) break;
2628 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002629 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002630 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002631 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002632 command->mTime = command2->mTime;
2633 // force delayMs to non 0 so that code below does not request to wait for
2634 // command status as the command is now delayed
2635 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002636 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002637
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002638 case SET_VOICE_VOLUME: {
2639 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2640 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2641 ALOGV("Filtering out voice volume command value %f replaced by %f",
2642 data2->mVolume, data->mVolume);
2643 removedCommands.add(command2);
2644 command->mTime = command2->mTime;
2645 // force delayMs to non 0 so that code below does not request to wait for
2646 // command status as the command is now delayed
2647 delayMs = 1;
2648 } break;
2649
Eric Laurente45b48a2014-09-04 16:40:57 -07002650 case CREATE_AUDIO_PATCH:
2651 case RELEASE_AUDIO_PATCH: {
2652 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002653 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002654 if (command->mCommand == CREATE_AUDIO_PATCH) {
2655 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002656 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002657 } else {
2658 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002659 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002660 }
2661 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002662 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002663 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2664 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002665 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002666 } else {
2667 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002668 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002669 }
2670 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002671 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2672 same output. */
2673 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2674 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2675 bool isOutputDiff = false;
2676 if (patch.num_sources == patch2.num_sources) {
2677 for (unsigned count = 0; count < patch.num_sources; count++) {
2678 if (patch.sources[count].id != patch2.sources[count].id) {
2679 isOutputDiff = true;
2680 break;
2681 }
2682 }
2683 if (isOutputDiff)
2684 break;
2685 }
2686 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002687 ALOGV("Filtering out %s audio patch command for handle %d",
2688 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2689 removedCommands.add(command2);
2690 command->mTime = command2->mTime;
2691 // force delayMs to non 0 so that code below does not request to wait for
2692 // command status as the command is now delayed
2693 delayMs = 1;
2694 } break;
2695
Jean-Michel Trivide801052015-04-14 19:10:14 -07002696 case DYN_POLICY_MIX_STATE_UPDATE: {
2697
2698 } break;
2699
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002700 case RECORDING_CONFIGURATION_UPDATE: {
2701
2702 } break;
2703
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002704 case ROUTING_UPDATED: {
2705
2706 } break;
2707
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002708 case VOL_RANGE_INIT_REQUEST: {
2709 // command may come from different requests, do not filter
2710 } break;
2711
Mathias Agopian65ab4712010-07-14 17:59:35 -07002712 default:
2713 break;
2714 }
2715 }
2716
2717 // remove filtered commands
2718 for (size_t j = 0; j < removedCommands.size(); j++) {
2719 // removed commands always have time stamps greater than current command
2720 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002721 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002722 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002723 mAudioCommands.removeAt(k);
2724 break;
2725 }
2726 }
2727 }
2728 removedCommands.clear();
2729
Eric Laurentaa79bef2015-01-15 14:33:51 -08002730 // Disable wait for status if delay is not 0.
2731 // Except for create audio patch command because the returned patch handle
2732 // is needed by audio policy manager
2733 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002734 command->mWaitStatus = false;
2735 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002736
Mathias Agopian65ab4712010-07-14 17:59:35 -07002737 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002738 ALOGV("inserting command: %d at index %zd, num commands %zu",
2739 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002740 mAudioCommands.insertAt(command, i + 1);
2741}
2742
2743void AudioPolicyService::AudioCommandThread::exit()
2744{
Steve Block3856b092011-10-20 11:56:00 +01002745 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002746 {
2747 AutoMutex _l(mLock);
2748 requestExit();
2749 mWaitWorkCV.signal();
2750 }
Zach Janga754b4f2015-10-27 01:29:34 +00002751 // Note that we can call it from the thread loop if all other references have been released
2752 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002753 requestExitAndWait();
2754}
2755
2756void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2757{
2758 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2759 mCommand,
2760 (int)ns2s(mTime),
2761 (int)ns2ms(mTime)%1000,
2762 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002763 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002764}
2765
Dima Zavinfce7a472011-04-19 22:30:36 -07002766/******* helpers for the service_ops callbacks defined below *********/
2767void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2768 const char *keyValuePairs,
2769 int delayMs)
2770{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002771 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002772 delayMs);
2773}
2774
2775int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2776 float volume,
2777 audio_io_handle_t output,
2778 int delayMs)
2779{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002780 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002781 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002782}
2783
Dima Zavinfce7a472011-04-19 22:30:36 -07002784int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2785{
2786 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2787}
2788
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002789void AudioPolicyService::setEffectSuspended(int effectId,
2790 audio_session_t sessionId,
2791 bool suspended)
2792{
2793 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2794}
2795
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002796Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002797{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002798 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002799 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002800}
2801
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002802
Dima Zavinfce7a472011-04-19 22:30:36 -07002803extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002804audio_module_handle_t aps_load_hw_module(void *service __unused,
2805 const char *name);
2806audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002807 audio_devices_t *pDevices,
2808 uint32_t *pSamplingRate,
2809 audio_format_t *pFormat,
2810 audio_channel_mask_t *pChannelMask,
2811 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002812 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002813
Eric Laurent2d388ec2014-03-07 13:25:54 -08002814audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002815 audio_module_handle_t module,
2816 audio_devices_t *pDevices,
2817 uint32_t *pSamplingRate,
2818 audio_format_t *pFormat,
2819 audio_channel_mask_t *pChannelMask,
2820 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002821 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002822 const audio_offload_info_t *offloadInfo);
2823audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002824 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002825 audio_io_handle_t output2);
2826int aps_close_output(void *service __unused, audio_io_handle_t output);
2827int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2828int aps_restore_output(void *service __unused, audio_io_handle_t output);
2829audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002830 audio_devices_t *pDevices,
2831 uint32_t *pSamplingRate,
2832 audio_format_t *pFormat,
2833 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002834 audio_in_acoustics_t acoustics __unused);
2835audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002836 audio_module_handle_t module,
2837 audio_devices_t *pDevices,
2838 uint32_t *pSamplingRate,
2839 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002840 audio_channel_mask_t *pChannelMask);
2841int aps_close_input(void *service __unused, audio_io_handle_t input);
2842int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002843int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002844 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002845 audio_io_handle_t dst_output);
2846char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2847 const char *keys);
2848void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2849 const char *kv_pairs, int delay_ms);
2850int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002851 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002852 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002853int aps_set_voice_volume(void *service, float volume, int delay_ms);
2854};
Dima Zavinfce7a472011-04-19 22:30:36 -07002855
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002856} // namespace android