blob: 2be51215c7224430dd33172079540c8c095a9f63 [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) \
jiabina84c3d32022-12-02 18:59:55 +0000158BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
159BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
160BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
161BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
162BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800163
164// singleton for Binder Method Statistics for IAudioPolicyService
165static auto& getIAudioPolicyServiceStatistics() {
166 using Code = int;
167
168#pragma push_macro("BINDER_METHOD_ENTRY")
169#undef BINDER_METHOD_ENTRY
170#define BINDER_METHOD_ENTRY(ENTRY) \
171 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
172
173 static mediautils::MethodStatistics<Code> methodStatistics{
174 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
175 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
176 };
177#pragma pop_macro("BINDER_METHOD_ENTRY")
178
179 return methodStatistics;
180}
181
Mathias Agopian65ab4712010-07-14 17:59:35 -0700182// ----------------------------------------------------------------------------
183
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530184static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
185{
186 AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);
187 status_t status = apm->initialize();
188 if (status != NO_ERROR) {
189 delete apm;
190 apm = nullptr;
191 }
192 return apm;
193}
194
195static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
196{
197 delete interface;
198}
199// ----------------------------------------------------------------------------
200
Mathias Agopian65ab4712010-07-14 17:59:35 -0700201AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700202 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700203 mAudioPolicyManager(NULL),
204 mAudioPolicyClient(NULL),
205 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530206 mCaptureStateNotifier(false),
207 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100208 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
209 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800210 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530211}
212
213void AudioPolicyService::loadAudioPolicyManager()
214{
215 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
216 if (mLibraryHandle != nullptr) {
217 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
218 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
219 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
220 const char *lastError = dlerror();
221 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
222 __func__, lastError != nullptr ? lastError : "no error");
223
224 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
225 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
226 lastError = dlerror();
227 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
228 __func__, lastError != nullptr ? lastError : "no error");
229 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
230 unloadAudioPolicyManager();
231 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
232 }
233 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700234}
235
236void AudioPolicyService::onFirstRef()
237{
Andy Hungd47aca22022-03-15 11:50:51 -0700238 // Log an AudioPolicy "constructor" mediametrics event on first ref.
239 // This records the time it takes to load the audio modules and devices.
240 mediametrics::Defer defer([beginNs = systemTime()] {
241 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
242 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
243 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
244 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700245 {
246 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800247
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700248 // start audio commands thread
249 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
250 // start output activity command thread
251 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700252
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700253 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530254
255 loadAudioPolicyManager();
256 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700257 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200258
bryant_liuba2b4392014-06-11 16:49:30 +0800259 // load audio processing modules
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000260 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
261 sp<UidPolicy> uidPolicy = new UidPolicy(this);
262 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700263 {
264 Mutex::Autolock _l(mLock);
265 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000266 mUidPolicy = uidPolicy;
267 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700268 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000269 uidPolicy->registerSelf();
270 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200271
Eric Laurent81dd0f52021-07-05 11:54:40 +0200272 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200273 if (mAudioPolicyManager != nullptr) {
274 Mutex::Autolock _l(mLock);
275 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
276 AudioDeviceTypeAddrVector devices;
277 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
278 if (hasSpatializer) {
279 mSpatializer = Spatializer::create(this);
280 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700281 if (mSpatializer == nullptr) {
282 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
283 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
284 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
285 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200286 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200287 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700288}
289
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530290void AudioPolicyService::unloadAudioPolicyManager()
291{
292 ALOGV("%s ", __func__);
293 if (mLibraryHandle != nullptr) {
294 dlclose(mLibraryHandle);
295 }
296 mLibraryHandle = nullptr;
297 mCreateAudioPolicyManager = nullptr;
298 mDestroyAudioPolicyManager = nullptr;
299}
300
Mathias Agopian65ab4712010-07-14 17:59:35 -0700301AudioPolicyService::~AudioPolicyService()
302{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700303 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700304 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700305
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530306 mDestroyAudioPolicyManager(mAudioPolicyManager);
307 unloadAudioPolicyManager();
308
Eric Laurentdce54a12014-03-10 12:19:46 -0700309 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700310
311 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800312 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800313
314 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800315 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000316
317 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800318 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700319}
320
321// A notification client is always registered by AudioSystem when the client process
322// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800323Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700324{
Eric Laurent12590252015-08-21 18:40:20 -0700325 if (client == 0) {
326 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800327 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700328 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800329 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700330
331 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800332 pid_t pid = IPCThreadState::self()->getCallingPid();
333 int64_t token = ((int64_t)uid<<32) | pid;
334
335 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700336 sp<NotificationClient> notificationClient = new NotificationClient(this,
337 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800338 uid,
339 pid);
340 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700341
luochaojiang908c7d72018-06-21 14:58:04 +0800342 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700343
Marco Nelissenf8880202014-11-14 07:58:25 -0800344 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700345 binder->linkToDeath(notificationClient);
346 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800347 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700348}
349
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800350Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700351{
352 Mutex::Autolock _l(mNotificationClientsLock);
353
354 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800355 pid_t pid = IPCThreadState::self()->getCallingPid();
356 int64_t token = ((int64_t)uid<<32) | pid;
357
358 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800359 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700360 }
luochaojiang908c7d72018-06-21 14:58:04 +0800361 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800362 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700363}
364
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800365Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100366{
367 Mutex::Autolock _l(mNotificationClientsLock);
368
369 uid_t uid = IPCThreadState::self()->getCallingUid();
370 pid_t pid = IPCThreadState::self()->getCallingPid();
371 int64_t token = ((int64_t)uid<<32) | pid;
372
373 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800374 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100375 }
376 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800377 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100378}
379
Eric Laurentb52c1522014-05-20 11:27:36 -0700380// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800381void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700382{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000383 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800384 {
385 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800386 int64_t token = ((int64_t)uid<<32) | pid;
387 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800388 for (size_t i = 0; i < mNotificationClients.size(); i++) {
389 if (mNotificationClients.valueAt(i)->uid() == uid) {
390 hasSameUid = true;
391 break;
392 }
393 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000394 }
395 {
396 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800397 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700398 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700399 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700400 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800401 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700402}
403
404void AudioPolicyService::onAudioPortListUpdate()
405{
406 mOutputCommandThread->updateAudioPortListCommand();
407}
408
409void AudioPolicyService::doOnAudioPortListUpdate()
410{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800411 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700412 for (size_t i = 0; i < mNotificationClients.size(); i++) {
413 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
414 }
415}
416
417void AudioPolicyService::onAudioPatchListUpdate()
418{
419 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700420}
421
Eric Laurentb52c1522014-05-20 11:27:36 -0700422void AudioPolicyService::doOnAudioPatchListUpdate()
423{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800424 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700425 for (size_t i = 0; i < mNotificationClients.size(); i++) {
426 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
427 }
428}
429
François Gaffiecfe17322018-11-07 13:41:29 +0100430void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
431{
432 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
433}
434
435void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
436{
437 Mutex::Autolock _l(mNotificationClientsLock);
438 for (size_t i = 0; i < mNotificationClients.size(); i++) {
439 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
440 }
441}
442
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700443void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700444{
445 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
446 regId.string(), state);
447 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
448}
449
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700450void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700451{
452 Mutex::Autolock _l(mNotificationClientsLock);
453 for (size_t i = 0; i < mNotificationClients.size(); i++) {
454 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
455 }
456}
457
Eric Laurenta9f86652018-11-28 17:23:11 -0800458void AudioPolicyService::onRecordingConfigurationUpdate(
459 int event,
460 const record_client_info_t *clientInfo,
461 const audio_config_base_t *clientConfig,
462 std::vector<effect_descriptor_t> clientEffects,
463 const audio_config_base_t *deviceConfig,
464 std::vector<effect_descriptor_t> effects,
465 audio_patch_handle_t patchHandle,
466 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800467{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800468 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800469 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800470}
471
Eric Laurenta9f86652018-11-28 17:23:11 -0800472void AudioPolicyService::doOnRecordingConfigurationUpdate(
473 int event,
474 const record_client_info_t *clientInfo,
475 const audio_config_base_t *clientConfig,
476 std::vector<effect_descriptor_t> clientEffects,
477 const audio_config_base_t *deviceConfig,
478 std::vector<effect_descriptor_t> effects,
479 audio_patch_handle_t patchHandle,
480 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800481{
482 Mutex::Autolock _l(mNotificationClientsLock);
483 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800484 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800485 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800486 }
487}
488
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700489void AudioPolicyService::onRoutingUpdated()
490{
491 mOutputCommandThread->routingChangedCommand();
492}
493
494void AudioPolicyService::doOnRoutingUpdated()
495{
496 Mutex::Autolock _l(mNotificationClientsLock);
497 for (size_t i = 0; i < mNotificationClients.size(); i++) {
498 mNotificationClients.valueAt(i)->onRoutingUpdated();
499 }
500}
501
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000502void AudioPolicyService::onVolumeRangeInitRequest()
503{
504 mOutputCommandThread->volRangeInitReqCommand();
505}
506
507void AudioPolicyService::doOnVolumeRangeInitRequest()
508{
509 Mutex::Autolock _l(mNotificationClientsLock);
510 for (size_t i = 0; i < mNotificationClients.size(); i++) {
511 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
512 }
513}
514
Eric Laurent81dd0f52021-07-05 11:54:40 +0200515void AudioPolicyService::onCheckSpatializer()
516{
517 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200518 onCheckSpatializer_l();
519}
520
521void AudioPolicyService::onCheckSpatializer_l()
522{
523 if (mSpatializer != nullptr) {
524 mOutputCommandThread->checkSpatializerCommand();
525 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200526}
527
528void AudioPolicyService::doOnCheckSpatializer()
529{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200530 ALOGV("%s mSpatializer %p level %d",
531 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200532
Eric Laurent39095982021-08-24 18:29:27 +0200533 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200534 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200535 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
536 audio_io_handle_t currentOutput = mSpatializer->getOutput();
537 audio_io_handle_t newOutput;
538 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
539 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200540
541 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200542 status_t status =
543 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100544 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
545 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200546 if (status == NO_ERROR && currentOutput == newOutput) {
547 return;
548 }
Eric Laurent15903592022-02-24 20:44:36 +0100549 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200550 mLock.unlock();
551 // It is OK to call detachOutput() is none is already attached.
552 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200553 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
554 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200555 }
Eric Laurent39095982021-08-24 18:29:27 +0200556 mLock.lock();
557 if (status != NO_ERROR) {
558 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
559 }
560 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
561 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200562 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200563
Eric Laurent39095982021-08-24 18:29:27 +0200564 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200565 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200566 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200567 }
568 }
569 }
570}
571
Eric Laurent11094172022-04-05 18:27:42 +0200572size_t AudioPolicyService::countActiveClientsOnOutput_l(
573 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100574 size_t count = 0;
575 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
576 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200577 if (client->io == output && client->active
578 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100579 count++;
580 }
581 }
582 return count;
583}
584
585void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
586 if (mSpatializer == nullptr) {
587 return;
588 }
589 mOutputCommandThread->updateActiveSpatializerTracksCommand();
590}
591
592void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
593{
Eric Laurent21270b62022-07-04 15:11:29 +0200594 if (mSpatializer == nullptr) {
595 return;
596 }
597 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200598 size_t activeClients;
599 {
600 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200601 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100602 }
Eric Laurent21270b62022-07-04 15:11:29 +0200603 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100604}
605
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800606status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
607 audio_patch_handle_t *handle,
608 int delayMs)
609{
610 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
611}
612
613status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
614 int delayMs)
615{
616 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
617}
618
Eric Laurente1715a42014-05-20 11:30:42 -0700619status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
620 int delayMs)
621{
622 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
623}
624
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800625AudioPolicyService::NotificationClient::NotificationClient(
626 const sp<AudioPolicyService>& service,
627 const sp<media::IAudioPolicyServiceClient>& client,
628 uid_t uid,
629 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800630 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100631 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700632{
633}
634
635AudioPolicyService::NotificationClient::~NotificationClient()
636{
637}
638
639void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
640{
641 sp<NotificationClient> keep(this);
642 sp<AudioPolicyService> service = mService.promote();
643 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800644 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700645 }
646}
647
648void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
649{
Eric Laurente8726fe2015-06-26 09:39:24 -0700650 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700651 mAudioPolicyServiceClient->onAudioPortListUpdate();
652 }
653}
654
655void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
656{
Eric Laurente8726fe2015-06-26 09:39:24 -0700657 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700658 mAudioPolicyServiceClient->onAudioPatchListUpdate();
659 }
660}
Eric Laurent57dae992011-07-24 13:36:09 -0700661
Pattydd807582021-11-04 21:01:03 +0800662void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100663 int flags)
664{
665 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
666 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
667 }
668}
669
670
Jean-Michel Trivide801052015-04-14 19:10:14 -0700671void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700672 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700673{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700674 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800675 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
676 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800677 }
678}
679
680void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800681 int event,
682 const record_client_info_t *clientInfo,
683 const audio_config_base_t *clientConfig,
684 std::vector<effect_descriptor_t> clientEffects,
685 const audio_config_base_t *deviceConfig,
686 std::vector<effect_descriptor_t> effects,
687 audio_patch_handle_t patchHandle,
688 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800689{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700690 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800691 status_t status = [&]() -> status_t {
692 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
693 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
694 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700695 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700696 legacy2aidl_audio_config_base_t_AudioConfigBase(
697 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800698 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
699 convertContainer<std::vector<media::EffectDescriptor>>(
700 clientEffects,
701 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700702 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700703 legacy2aidl_audio_config_base_t_AudioConfigBase(
704 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800705 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
706 convertContainer<std::vector<media::EffectDescriptor>>(
707 effects,
708 legacy2aidl_effect_descriptor_t_EffectDescriptor));
709 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
710 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700711 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
712 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800713 return aidl_utils::statusTFromBinderStatus(
714 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
715 clientInfoAidl,
716 clientConfigAidl,
717 clientEffectsAidl,
718 deviceConfigAidl,
719 effectsAidl,
720 patchHandleAidl,
721 sourceAidl));
722 }();
723 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700724 }
725}
726
Eric Laurente8726fe2015-06-26 09:39:24 -0700727void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
728{
729 mAudioPortCallbacksEnabled = enabled;
730}
731
François Gaffiecfe17322018-11-07 13:41:29 +0100732void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
733{
734 mAudioVolumeGroupCallbacksEnabled = enabled;
735}
Eric Laurente8726fe2015-06-26 09:39:24 -0700736
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700737void AudioPolicyService::NotificationClient::onRoutingUpdated()
738{
739 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
740 mAudioPolicyServiceClient->onRoutingUpdated();
741 }
742}
743
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000744void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
745{
746 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
747 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
748 }
749}
750
Mathias Agopian65ab4712010-07-14 17:59:35 -0700751void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700752 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700753 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700754}
755
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000756static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700757{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000758 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
759}
760
761static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
762{
763 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700764}
765
766status_t AudioPolicyService::dumpInternals(int fd)
767{
768 const size_t SIZE = 256;
769 char buffer[SIZE];
770 String8 result;
771
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000772 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800773 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000774 std::stringstream msg;
775 size_t i = 0;
776 for (auto usage : mSupportedSystemUsages) {
777 if (i++ != 0) msg << ", ";
778 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
779 msg << strUsage;
780 } else {
781 msg << usage << " (unknown)";
782 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800783 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000784 if (i == 0) {
785 msg << "None";
786 }
787 msg << std::endl;
788 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800789
Mathias Agopian65ab4712010-07-14 17:59:35 -0700790 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800791
792 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700793 return NO_ERROR;
794}
795
Eric Laurente8c8b432018-10-17 10:08:02 -0700796void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800797{
Eric Laurente8c8b432018-10-17 10:08:02 -0700798 Mutex::Autolock _l(mLock);
799 updateUidStates_l();
800}
801
802void AudioPolicyService::updateUidStates_l()
803{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800804// Go over all active clients and allow capture (does not force silence) in the
805// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800806// The client is in the active assistant list
807// AND is TOP
808// AND an accessibility service is TOP
809// AND source is either VOICE_RECOGNITION OR HOTWORD
810// OR there is no active privacy sensitive capture or call
811// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
812// AND source is VOICE_RECOGNITION OR HOTWORD
813// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800814// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700815// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800816// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800817// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800818// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
819// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800820// OR The client is an accessibility service
821// AND Is on TOP
822// AND the source is VOICE_RECOGNITION or HOTWORD
823// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700824// AND there is no active privacy sensitive capture or call
825// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800826// AND is on TOP
827// AND the source is VOICE_RECOGNITION or HOTWORD
828// OR the client source is virtual (remote submix, call audio TX or RX...)
829// OR the client source is HOTWORD
830// AND is on TOP
831// OR all active clients are using HOTWORD source
832// AND no call is active
833// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
834// OR the client is the current InputMethodService
835// AND a RTT call is active AND the source is VOICE_RECOGNITION
836// OR Any client
837// AND The assistant is not on TOP
838// AND is on TOP or latest started
839// AND there is no active privacy sensitive capture or call
840// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800841
Eric Laurent4e947da2019-10-17 15:24:06 -0700842
Eric Laurent4eb58f12018-12-07 16:41:02 -0800843 sp<AudioRecordClient> topActive;
844 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800845 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700846 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800847 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700848
Eric Laurenta46bedb2018-12-07 18:01:26 -0800849 nsecs_t topStartNs = 0;
850 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800851 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800852 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800853 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800854 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
855 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800856 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800857 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700858 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800859 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
860 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700861 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700862 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700863 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800864
Michael Groovercfd28302018-12-11 19:16:46 -0800865 // if Sensor Privacy is enabled then all recordings should be silenced.
866 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
867 silenceAllRecordings_l();
868 return;
869 }
870
Eric Laurente8c8b432018-10-17 10:08:02 -0700871 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
872 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000873 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
874 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800875 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700876 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800877 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700878
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700879 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700880 // clients which app is in IDLE state are not eligible for top active or
881 // latest active
882 if (appState == APP_STATE_IDLE) {
883 continue;
884 }
885
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700886 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700887 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800888 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700889 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700890 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800891 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800892 bool isPrivacySensitive =
893 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700894
Eric Laurentc21d5692020-02-25 10:24:36 -0800895 if (appState == APP_STATE_TOP) {
896 if (isPrivacySensitive) {
897 if (current->startTimeNs > topSensitiveStartNs) {
898 topSensitiveActive = current;
899 topSensitiveStartNs = current->startTimeNs;
900 }
901 } else {
902 if (current->startTimeNs > topStartNs) {
903 topActive = current;
904 topStartNs = current->startTimeNs;
905 }
906 }
907 if (isAssistant) {
908 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800909 if (isActiveAssistant) {
910 useActiveAssistantList = true;
911 } else if (!useActiveAssistantList) {
912 if (current->startTimeNs > latestAssistantStartNs) {
913 latestActiveAssistant = current;
914 latestAssistantStartNs = current->startTimeNs;
915 }
916 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800917 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800918 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800919 // Clients capturing for HOTWORD are not considered
920 // for latest active to avoid masking regular clients started before
921 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
922 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
923 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700924 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
925 // is marked latest sensitive active even if another app qualifies.
926 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700927 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700928 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700929 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000930 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700931 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700932 latestSensitiveActiveOrComm = current;
933 latestSensitiveStartNs = current->startTimeNs;
934 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800935 }
936 isSensitiveActive = true;
937 } else {
938 if (current->startTimeNs > latestStartNs) {
939 latestActive = current;
940 latestStartNs = current->startTimeNs;
941 }
942 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800943 }
944 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700945 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
946 onlyHotwordActive = false;
947 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100948 if (currentUid == mPhoneStateOwnerUid &&
949 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700950 isPhoneStateOwnerActive = true;
951 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800952 }
953
Eric Laurent1ff16a72019-03-14 18:35:04 -0700954 // if no active client with UI on Top, consider latest active as top
955 if (topActive == nullptr) {
956 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800957 topStartNs = latestStartNs;
958 }
959 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700960 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800961 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700962 } else if (latestSensitiveActiveOrComm != nullptr) {
963 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
964 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700965 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000966 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700967 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700968 topSensitiveActive = latestSensitiveActiveOrComm;
969 topSensitiveStartNs = latestSensitiveStartNs;
970 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800971 }
972
973 // If both privacy sensitive and regular capture are active:
974 // if the regular capture is privileged
975 // allow concurrency
976 // else
977 // favor the privacy sensitive case
978 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700979 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800980 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800981 }
982
983 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
984 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700985 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000986 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700987 if (!current->active) {
988 continue;
989 }
990
Eric Laurent4eb58f12018-12-07 16:41:02 -0800991 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700992 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000993 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700994 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000995 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800996 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
997 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -0800998
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000999 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001000 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001001 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001002 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001003 bool canCaptureCommunication = recordClient->canCaptureOutput
1004 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001005 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001006 return !(isInCall && !canCaptureCall)
1007 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001008 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001009
1010 // By default allow capture if:
1011 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001012 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001013 // AND there is no active privacy sensitive capture or call
1014 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001015 bool allowSensitiveCapture =
1016 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001017 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001018 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001019 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001020 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001021
Eric Laurented726cc2021-07-01 14:26:41 +02001022 if (!current->hasOp()) {
1023 // Never allow capture if app op is denied
1024 allowCapture = false;
1025 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001026 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1027 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001028 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001029 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001030 // Active assistant list is not being used
1031 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001032 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001033 // OR there is no active privacy sensitive capture or call
1034 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1035 // AND is latest TOP assistant AND
1036 // uses VOICE_RECOGNITION OR uses HOTWORD
1037 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001038 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001039 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001040 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001041 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001042 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001043 && canCaptureIfInCallOrCommunication(current)) {
1044 if (isTopOrLatestAssistant
1045 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1046 || source == AUDIO_SOURCE_HOTWORD)) {
1047 allowCapture = true;
1048 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1049 allowCapture = true;
1050 }
1051 }
1052 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1053 // For assistant on active list and on top allow capture if:
1054 // An accessibility service is on TOP
1055 // AND the source is VOICE_RECOGNITION or HOTWORD
1056 // OR there is no active privacy sensitive capture or call
1057 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1058 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1059 if (isA11yOnTop) {
1060 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1061 allowCapture = true;
1062 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001063 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001064 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001065 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1066 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001067 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001068 }
1069 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001070 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001071 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001072 // The assistant is not on TOP
1073 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001074 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001075 // OR
1076 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1077 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001078 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001079 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001080 allowCapture = true;
1081 }
Eric Laurent589171c2019-07-25 18:04:29 -07001082 if (isA11yOnTop) {
1083 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1084 allowCapture = true;
1085 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001086 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001087 } else if (source == AUDIO_SOURCE_HOTWORD) {
1088 // For HOTWORD source allow capture when not on TOP if:
1089 // All active clients are using HOTWORD source
1090 // AND no call is active
1091 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001092 if (onlyHotwordActive
1093 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001094 allowCapture = true;
1095 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001096 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001097 // For current InputMethodService allow capture if:
1098 // A RTT call is active AND the source is VOICE_RECOGNITION
1099 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1100 allowCapture = true;
1101 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001102 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001103 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001104 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001105 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001106 }
1107}
1108
Michael Groovercfd28302018-12-11 19:16:46 -08001109void AudioPolicyService::silenceAllRecordings_l() {
1110 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1111 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001112 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001113 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001114 }
Michael Groovercfd28302018-12-11 19:16:46 -08001115 }
1116}
1117
Eric Laurente8c8b432018-10-17 10:08:02 -07001118/* static */
1119app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001120
1121 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001122 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001123 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1124 // include persistent services
1125 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001126 }
1127 return APP_STATE_FOREGROUND;
1128}
1129
Eric Laurent4eb58f12018-12-07 16:41:02 -08001130/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001131bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001132{
1133 switch (source) {
1134 case AUDIO_SOURCE_VOICE_UPLINK:
1135 case AUDIO_SOURCE_VOICE_DOWNLINK:
1136 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001137 case AUDIO_SOURCE_REMOTE_SUBMIX:
1138 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001139 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001140 return true;
1141 default:
1142 break;
1143 }
1144 return false;
1145}
1146
Eric Laurented726cc2021-07-01 14:26:41 +02001147/* static */
1148bool AudioPolicyService::isAppOpSource(audio_source_t source)
1149{
1150 switch (source) {
1151 case AUDIO_SOURCE_FM_TUNER:
1152 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001153 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001154 return false;
1155 default:
1156 break;
1157 }
1158 return true;
1159}
1160
Eric Laurent8c7ef892021-06-10 13:32:16 +02001161void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001162{
1163 AutoCallerClear acc;
1164
1165 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001166 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001167 }
1168 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1169 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001170 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001171 if (client->silenced != silenced) {
1172 if (client->active) {
1173 if (silenced) {
1174 finishRecording(client->attributionSource, client->attributes.source);
1175 } else {
1176 std::stringstream msg;
1177 msg << "Audio recording un-silenced on session " << client->session;
1178 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1179 client->attributes.source)) {
1180 silenced = true;
1181 }
1182 }
1183 }
1184 af->setRecordSilenced(client->portId, silenced);
1185 client->silenced = silenced;
1186 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001187 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001188}
1189
Glenn Kasten0f11b512014-01-31 16:18:54 -08001190status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001191{
Glenn Kasten44deb052012-02-05 18:09:08 -08001192 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001193 dumpPermissionDenial(fd);
1194 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001195 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001196 if (!locked) {
1197 String8 result(kDeadlockedString);
1198 write(fd, result.string(), result.size());
1199 }
1200
1201 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001202
1203 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1204 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001205 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001206 mAudioCommandThread->dump(fd);
1207 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001208
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001209 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1210 write(fd, octPtr.string(), octPtr.size());
1211 if (mOutputCommandThread != 0) {
1212 mOutputCommandThread->dump(fd);
1213 }
1214
Eric Laurentdce54a12014-03-10 12:19:46 -07001215 if (mAudioPolicyManager) {
1216 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001217 } else {
1218 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1219 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001220 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001221
Kevin Rocard8be94972019-02-22 13:26:25 -08001222 mPackageManager.dump(fd);
1223
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001224 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001225
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001226 if (mSpatializer != nullptr) {
1227 std::string dumpString = mSpatializer->toString(1 /* level */);
1228 write(fd, dumpString.c_str(), dumpString.size());
1229 } else {
1230 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1231 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1232 }
1233
Andy Hungc747c532022-03-07 21:41:14 -08001234 {
1235 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1236 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1237 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1238 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001239 }
1240 return NO_ERROR;
1241}
1242
1243status_t AudioPolicyService::dumpPermissionDenial(int fd)
1244{
1245 const size_t SIZE = 256;
1246 char buffer[SIZE];
1247 String8 result;
1248 snprintf(buffer, SIZE, "Permission Denial: "
1249 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1250 IPCThreadState::self()->getCallingPid(),
1251 IPCThreadState::self()->getCallingUid());
1252 result.append(buffer);
1253 write(fd, result.string(), result.size());
1254 return NO_ERROR;
1255}
1256
1257status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001258 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001259 // make sure transactions reserved to AudioFlinger do not come from other processes
1260 switch (code) {
1261 case TRANSACTION_startOutput:
1262 case TRANSACTION_stopOutput:
1263 case TRANSACTION_releaseOutput:
1264 case TRANSACTION_getInputForAttr:
1265 case TRANSACTION_startInput:
1266 case TRANSACTION_stopInput:
1267 case TRANSACTION_releaseInput:
1268 case TRANSACTION_getOutputForEffect:
1269 case TRANSACTION_registerEffect:
1270 case TRANSACTION_unregisterEffect:
1271 case TRANSACTION_setEffectEnabled:
1272 case TRANSACTION_getStrategyForStream:
1273 case TRANSACTION_getOutputForAttr:
1274 case TRANSACTION_moveEffectsToIo:
1275 ALOGW("%s: transaction %d received from PID %d",
1276 __func__, code, IPCThreadState::self()->getCallingPid());
1277 return INVALID_OPERATION;
1278 default:
1279 break;
1280 }
1281
1282 // make sure the following transactions come from system components
1283 switch (code) {
1284 case TRANSACTION_setDeviceConnectionState:
1285 case TRANSACTION_handleDeviceConfigChange:
1286 case TRANSACTION_setPhoneState:
1287//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1288// case TRANSACTION_setForceUse:
1289 case TRANSACTION_initStreamVolume:
1290 case TRANSACTION_setStreamVolumeIndex:
1291 case TRANSACTION_setVolumeIndexForAttributes:
1292 case TRANSACTION_getStreamVolumeIndex:
1293 case TRANSACTION_getVolumeIndexForAttributes:
1294 case TRANSACTION_getMinVolumeIndexForAttributes:
1295 case TRANSACTION_getMaxVolumeIndexForAttributes:
1296 case TRANSACTION_isStreamActive:
1297 case TRANSACTION_isStreamActiveRemotely:
1298 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001299 case TRANSACTION_registerPolicyMixes:
1300 case TRANSACTION_setMasterMono:
1301 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001302 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001303 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001304 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001305 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001306 case TRANSACTION_setA11yServicesUids:
1307 case TRANSACTION_setUidDeviceAffinities:
1308 case TRANSACTION_removeUidDeviceAffinities:
1309 case TRANSACTION_setUserIdDeviceAffinities:
1310 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001311 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001312 case TRANSACTION_listAudioVolumeGroups:
1313 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1314 case TRANSACTION_acquireSoundTriggerSession:
1315 case TRANSACTION_releaseSoundTriggerSession:
1316 case TRANSACTION_setRttEnabled:
1317 case TRANSACTION_isCallScreenModeSupported:
1318 case TRANSACTION_setDevicesRoleForStrategy:
1319 case TRANSACTION_setSupportedSystemUsages:
1320 case TRANSACTION_removeDevicesRoleForStrategy:
1321 case TRANSACTION_getDevicesForRoleAndStrategy:
1322 case TRANSACTION_getDevicesForAttributes:
1323 case TRANSACTION_setAllowedCapturePolicy:
1324 case TRANSACTION_onNewAudioModulesAvailable:
1325 case TRANSACTION_setCurrentImeUid:
1326 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1327 case TRANSACTION_setDevicesRoleForCapturePreset:
1328 case TRANSACTION_addDevicesRoleForCapturePreset:
1329 case TRANSACTION_removeDevicesRoleForCapturePreset:
1330 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001331 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001332 case TRANSACTION_getSpatializer:
1333 case TRANSACTION_setPreferredMixerAttributes:
1334 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001335 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1336 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1337 __func__, code, IPCThreadState::self()->getCallingPid(),
1338 IPCThreadState::self()->getCallingUid());
1339 return INVALID_OPERATION;
1340 }
1341 } break;
1342 default:
1343 break;
1344 }
1345
Andy Hungc747c532022-03-07 21:41:14 -08001346 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1347 mediautils::TimeCheck check(
1348 std::string("IAudioPolicyService::").append(methodName),
1349 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1350 if (timeout) {
1351 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1352 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1353 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1354 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1355 .record();
1356 } else {
1357 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1358 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001359 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1360 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1361 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001362
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001363 switch (code) {
1364 case SHELL_COMMAND_TRANSACTION: {
1365 int in = data.readFileDescriptor();
1366 int out = data.readFileDescriptor();
1367 int err = data.readFileDescriptor();
1368 int argc = data.readInt32();
1369 Vector<String16> args;
1370 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1371 args.add(data.readString16());
1372 }
1373 sp<IBinder> unusedCallback;
1374 sp<IResultReceiver> resultReceiver;
1375 status_t status;
1376 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1377 return status;
1378 }
1379 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1380 return status;
1381 }
1382 status = shellCommand(in, out, err, args);
1383 if (resultReceiver != nullptr) {
1384 resultReceiver->send(status);
1385 }
1386 return NO_ERROR;
1387 }
1388 }
1389
Mathias Agopian65ab4712010-07-14 17:59:35 -07001390 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1391}
1392
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001393// ------------------- Shell command implementation -------------------
1394
1395// NOTE: This is a remote API - make sure all args are validated
1396status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1397 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1398 return PERMISSION_DENIED;
1399 }
1400 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1401 return BAD_VALUE;
1402 }
jovanakbe066e12019-09-02 11:54:39 -07001403 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001404 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001405 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001406 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001407 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001408 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001409 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1410 purgePermissionCache();
1411 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001412 } else if (args.size() == 1 && args[0] == String16("help")) {
1413 printHelp(out);
1414 return NO_ERROR;
1415 }
1416 printHelp(err);
1417 return BAD_VALUE;
1418}
1419
jovanakbe066e12019-09-02 11:54:39 -07001420static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1421 if (userId < 0) {
1422 ALOGE("Invalid user: %d", userId);
1423 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001424 return BAD_VALUE;
1425 }
jovanakbe066e12019-09-02 11:54:39 -07001426
1427 PermissionController pc;
1428 uid = pc.getPackageUid(packageName, 0);
1429 if (uid <= 0) {
1430 ALOGE("Unknown package: '%s'", String8(packageName).string());
1431 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1432 return BAD_VALUE;
1433 }
1434
1435 uid = multiuser_get_uid(userId, uid);
1436 return NO_ERROR;
1437}
1438
1439status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1440 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1441 if (!(args.size() == 3 || args.size() == 5)) {
1442 printHelp(err);
1443 return BAD_VALUE;
1444 }
1445
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001446 bool active = false;
1447 if (args[2] == String16("active")) {
1448 active = true;
1449 } else if ((args[2] != String16("idle"))) {
1450 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1451 return BAD_VALUE;
1452 }
jovanakbe066e12019-09-02 11:54:39 -07001453
1454 int userId = 0;
1455 if (args.size() >= 5 && args[3] == String16("--user")) {
1456 userId = atoi(String8(args[4]));
1457 }
1458
1459 uid_t uid;
1460 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1461 return BAD_VALUE;
1462 }
1463
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001464 sp<UidPolicy> uidPolicy;
1465 {
1466 Mutex::Autolock _l(mLock);
1467 uidPolicy = mUidPolicy;
1468 }
1469 if (uidPolicy) {
1470 uidPolicy->addOverrideUid(uid, active);
1471 return NO_ERROR;
1472 }
1473 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001474}
1475
1476status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001477 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1478 if (!(args.size() == 2 || args.size() == 4)) {
1479 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001480 return BAD_VALUE;
1481 }
jovanakbe066e12019-09-02 11:54:39 -07001482
1483 int userId = 0;
1484 if (args.size() >= 4 && args[2] == String16("--user")) {
1485 userId = atoi(String8(args[3]));
1486 }
1487
1488 uid_t uid;
1489 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1490 return BAD_VALUE;
1491 }
1492
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001493 sp<UidPolicy> uidPolicy;
1494 {
1495 Mutex::Autolock _l(mLock);
1496 uidPolicy = mUidPolicy;
1497 }
1498 if (uidPolicy) {
1499 uidPolicy->removeOverrideUid(uid);
1500 return NO_ERROR;
1501 }
1502 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001503}
1504
1505status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001506 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1507 if (!(args.size() == 2 || args.size() == 4)) {
1508 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001509 return BAD_VALUE;
1510 }
jovanakbe066e12019-09-02 11:54:39 -07001511
1512 int userId = 0;
1513 if (args.size() >= 4 && args[2] == String16("--user")) {
1514 userId = atoi(String8(args[3]));
1515 }
1516
1517 uid_t uid;
1518 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1519 return BAD_VALUE;
1520 }
1521
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001522 sp<UidPolicy> uidPolicy;
1523 {
1524 Mutex::Autolock _l(mLock);
1525 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001526 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001527 if (uidPolicy) {
1528 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1529 }
1530 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001531}
1532
1533status_t AudioPolicyService::printHelp(int out) {
1534 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001535 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1536 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1537 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001538 " help print this message\n");
1539}
1540
Eric Laurent0d13fea2022-11-04 17:12:08 +01001541status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1542 const audio_config_base_t& config,
1543 const audio_output_flags_t flags) {
1544 return mUsecaseValidator->registerStream(output, config, flags);
1545}
1546
1547status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1548 return mUsecaseValidator->unregisterStream(output);
1549}
1550
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001551// ----------- AudioPolicyService::UidPolicy implementation ----------
1552
1553void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001554 status_t res = mAm.linkToDeath(this);
1555 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001556 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001557 | ActivityManager::UID_OBSERVER_ACTIVE
1558 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001559 ActivityManager::PROCESS_STATE_UNKNOWN,
1560 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001561 if (!res) {
1562 Mutex::Autolock _l(mLock);
1563 mObserverRegistered = true;
1564 } else {
1565 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001566
Steven Moreland2f348142019-07-02 15:59:07 -07001567 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001568 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001569}
1570
1571void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001572 mAm.unlinkToDeath(this);
1573 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001574 Mutex::Autolock _l(mLock);
1575 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001576}
1577
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001578void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1579 Mutex::Autolock _l(mLock);
1580 mCachedUids.clear();
1581 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001582}
1583
Eric Laurente8c8b432018-10-17 10:08:02 -07001584void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001585 bool needToReregister = false;
1586 {
1587 Mutex::Autolock _l(mLock);
1588 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001589 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001590 if (needToReregister) {
1591 // Looks like ActivityManager has died previously, attempt to re-register.
1592 registerSelf();
1593 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001594}
1595
1596bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1597 if (isServiceUid(uid)) return true;
1598 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001599 {
1600 Mutex::Autolock _l(mLock);
1601 auto overrideIter = mOverrideUids.find(uid);
1602 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001603 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001604 }
1605 // In an absense of the ActivityManager, assume everything to be active.
1606 if (!mObserverRegistered) return true;
1607 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001608 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001609 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001610 }
1611 }
1612 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001613 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001614 {
1615 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001616 mCachedUids.insert(std::pair<uid_t,
1617 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1618 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001619 }
1620 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001621}
1622
Eric Laurente8c8b432018-10-17 10:08:02 -07001623int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1624 if (isServiceUid(uid)) {
1625 return ActivityManager::PROCESS_STATE_TOP;
1626 }
1627 checkRegistered();
1628 {
1629 Mutex::Autolock _l(mLock);
1630 auto overrideIter = mOverrideUids.find(uid);
1631 if (overrideIter != mOverrideUids.end()) {
1632 if (overrideIter->second.first) {
1633 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1634 return overrideIter->second.second;
1635 } else {
1636 auto cacheIter = mCachedUids.find(uid);
1637 if (cacheIter != mCachedUids.end()) {
1638 return cacheIter->second.second;
1639 }
1640 }
1641 }
1642 return ActivityManager::PROCESS_STATE_UNKNOWN;
1643 }
1644 // In an absense of the ActivityManager, assume everything to be active.
1645 if (!mObserverRegistered) {
1646 return ActivityManager::PROCESS_STATE_TOP;
1647 }
1648 auto cacheIter = mCachedUids.find(uid);
1649 if (cacheIter != mCachedUids.end()) {
1650 if (cacheIter->second.first) {
1651 return cacheIter->second.second;
1652 } else {
1653 return ActivityManager::PROCESS_STATE_UNKNOWN;
1654 }
1655 }
1656 }
1657 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001658 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001659 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1660 if (active) {
1661 state = am.getUidProcessState(uid, String16("audioserver"));
1662 }
1663 {
1664 Mutex::Autolock _l(mLock);
1665 mCachedUids.insert(std::pair<uid_t,
1666 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1667 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001668
Eric Laurente8c8b432018-10-17 10:08:02 -07001669 return state;
1670}
1671
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001672void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001673 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001674}
1675
1676void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001677 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001678}
1679
1680void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001681 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001682}
1683
Eric Laurente8c8b432018-10-17 10:08:02 -07001684void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1685 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001686 int64_t procStateSeq __unused,
1687 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001688 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1689 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001690 }
1691}
1692
Austin Borger65577682022-02-17 00:25:43 +00001693void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1694}
1695
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001696void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001697 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1698}
1699
1700void AudioPolicyService::UidPolicy::notifyService() {
1701 sp<AudioPolicyService> service = mService.promote();
1702 if (service != nullptr) {
1703 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001704 }
1705}
1706
Eric Laurente8c8b432018-10-17 10:08:02 -07001707void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1708 std::pair<bool, int>> *uids,
1709 uid_t uid,
1710 bool active,
1711 int state,
1712 bool insert) {
1713 if (isServiceUid(uid)) {
1714 return;
1715 }
1716 bool wasActive = isUidActive(uid);
1717 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001718 {
1719 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001720 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001721 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001722 if (wasActive != isUidActive(uid) || state != previousState) {
1723 notifyService();
1724 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001725}
1726
Eric Laurente8c8b432018-10-17 10:08:02 -07001727void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1728 std::pair<bool, int>> *uids,
1729 uid_t uid,
1730 bool active,
1731 int state,
1732 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001733 auto it = uids->find(uid);
1734 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001735 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001736 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1737 it->second.first = active;
1738 }
1739 if (it->second.first) {
1740 it->second.second = state;
1741 } else {
1742 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1743 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001744 } else {
1745 uids->erase(it);
1746 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001747 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1748 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1749 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001750 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001751}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001752
Eric Laurent4eb58f12018-12-07 16:41:02 -08001753bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001754 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001755 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001756 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001757 continue;
1758 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001759 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1760 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001761 return true;
1762 }
1763 }
1764 return false;
1765}
1766
Eric Laurentb78763e2018-10-17 10:08:02 -07001767bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1768{
1769 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1770 return it != mA11yUids.end();
1771}
1772
Oscar Azucena829d90d2022-01-28 17:17:56 -08001773void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1774 mAssistantUids.clear();
1775 mAssistantUids = uids;
1776}
1777
1778bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1779{
1780 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1781 return it != mAssistantUids.end();
1782}
1783
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001784void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1785 mActiveAssistantUids = activeUids;
1786}
1787
1788bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1789{
1790 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1791 mActiveAssistantUids.end(), uid);
1792 return it != mActiveAssistantUids.end();
1793}
1794
Oscar Azucena829d90d2022-01-28 17:17:56 -08001795void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1796 const size_t SIZE = 256;
1797 char buffer[SIZE];
1798 String8 result;
1799 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1800 snprintf(buffer, SIZE, "\t%s: \n", title);
1801 result.append(buffer);
1802 int counter = 0;
1803 if (uids.empty()) {
1804 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1805 result.append(buffer);
1806 return;
1807 }
1808 for (const auto &uid : uids) {
1809 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1810 result.append(buffer);
1811 }
1812 };
1813
1814 snprintf(buffer, SIZE, "UID Policy:\n");
1815 result.append(buffer);
1816 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1817 result.append(buffer);
1818
1819 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001820 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001821
1822 appendUidsToResult("Accessibility UIDs", mA11yUids);
1823
1824 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1825 result.append(buffer);
1826
1827 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1828 result.append(buffer);
1829
1830 write(fd, result.string(), result.size());
1831}
1832
Michael Groovercfd28302018-12-11 19:16:46 -08001833// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1834void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1835 SensorPrivacyManager spm;
1836 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
Eric Laurent35cd7932022-11-17 11:47:19 +01001837 (void)spm.addToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001838 spm.addSensorPrivacyListener(this);
1839}
1840
1841void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1842 SensorPrivacyManager spm;
1843 spm.removeSensorPrivacyListener(this);
Eric Laurent35cd7932022-11-17 11:47:19 +01001844 spm.removeToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001845}
1846
1847bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1848 return mSensorPrivacyEnabled;
1849}
1850
Evan Seversond8dc6832022-01-27 10:47:03 -08001851binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1852 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001853 mSensorPrivacyEnabled = enabled;
1854 sp<AudioPolicyService> service = mService.promote();
1855 if (service != nullptr) {
1856 service->updateUidStates();
1857 }
1858 return binder::Status::ok();
1859}
1860
Eric Laurented726cc2021-07-01 14:26:41 +02001861// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1862
1863// static
1864sp<AudioPolicyService::OpRecordAudioMonitor>
1865AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1866 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1867 wp<AudioCommandThread> commandThread)
1868{
Eric Laurent987ce102021-07-05 12:11:51 +02001869 if (isAudioServerOrRootUid(attributionSource.uid)) {
1870 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001871 attributionSource.toString().c_str());
1872 return nullptr;
1873 }
1874
1875 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1876 ALOGD("not monitoring app op for uid %d and source %d",
1877 attributionSource.uid, attr.source);
1878 return nullptr;
1879 }
1880
1881 if (!attributionSource.packageName.has_value()
1882 || attributionSource.packageName.value().size() == 0) {
1883 return nullptr;
1884 }
1885 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1886}
1887
1888AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1889 const AttributionSourceState& attributionSource, int32_t appOp,
1890 wp<AudioCommandThread> commandThread) :
1891 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1892 mCommandThread(commandThread)
1893{
1894}
1895
1896AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1897{
1898 if (mOpCallback != 0) {
1899 mAppOpsManager.stopWatchingMode(mOpCallback);
1900 }
1901 mOpCallback.clear();
1902}
1903
1904void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1905{
1906 checkOp();
1907 mOpCallback = new RecordAudioOpCallback(this);
1908 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1909 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1910 // since it controls the mic permission for legacy apps.
1911 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1912 mAttributionSource.packageName.value_or(""))),
1913 mOpCallback);
1914}
1915
1916bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1917 return mHasOp.load();
1918}
1919
1920// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1921// is updated in AppOp callback and in onFirstRef()
1922// Note this method is never called (and never to be) for audio server / root track
1923// due to the UID in createIfNeeded(). As a result for those record track, it's:
1924// - not called from constructor,
1925// - not called from RecordAudioOpCallback because the callback is not installed in this case
1926void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1927{
1928 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1929 // since it controls the mic permission for legacy apps.
1930 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1931 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1932 mAttributionSource.packageName.value_or(""))));
1933 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1934 // verbose logging only log when appOp changed
1935 ALOGI_IF(hasIt != mHasOp.load(),
1936 "App op %d missing, %ssilencing record %s",
1937 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1938 mHasOp.store(hasIt);
1939
1940 if (updateUidStates) {
1941 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1942 if (commandThread != nullptr) {
1943 commandThread->updateUidStatesCommand();
1944 }
1945 }
1946}
1947
1948AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1949 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1950{ }
1951
1952void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1953 const String16& packageName __unused) {
1954 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1955 if (monitor != NULL) {
1956 if (op != monitor->getOp()) {
1957 return;
1958 }
1959 monitor->checkOp(true);
1960 }
1961}
1962
1963
Mathias Agopian65ab4712010-07-14 17:59:35 -07001964// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1965
Eric Laurentbfb1b832013-01-07 09:53:42 -08001966AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1967 const wp<AudioPolicyService>& service)
1968 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001969{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001970}
1971
1972
1973AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1974{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001975 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001976 release_wake_lock(mName.string());
1977 }
1978 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001979}
1980
1981void AudioPolicyService::AudioCommandThread::onFirstRef()
1982{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001983 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001984}
1985
1986bool AudioPolicyService::AudioCommandThread::threadLoop()
1987{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001988 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001989
1990 mLock.lock();
1991 while (!exitPending())
1992 {
Eric Laurent59a89232014-06-08 14:14:17 -07001993 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001994 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001995 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001996 nsecs_t curTime = systemTime();
1997 // commands are sorted by increasing time stamp: execute them from index 0 and up
1998 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001999 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002000 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002001 if (mAudioCommands.isEmpty()) {
2002 ++numTimesBecameEmpty;
2003 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002004 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002005
2006 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002007 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002008 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002009 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07002010 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002011 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07002012 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
2013 data->mVolume,
2014 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002015 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002016 }break;
2017 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002018 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002019 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2020 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002021 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002022 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002023 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002024 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002025 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002026 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002027 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002028 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002029 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002030 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002031 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002032 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002033 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002034 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002035 ALOGV("AudioCommandThread() processing stop output portId %d",
2036 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002037 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002038 if (svc == 0) {
2039 break;
2040 }
2041 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002042 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002043 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002044 }break;
2045 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002046 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002047 ALOGV("AudioCommandThread() processing release output portId %d",
2048 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002049 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002050 if (svc == 0) {
2051 break;
2052 }
2053 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002054 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002055 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002056 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002057 case CREATE_AUDIO_PATCH: {
2058 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2059 ALOGV("AudioCommandThread() processing create audio patch");
2060 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2061 if (af == 0) {
2062 command->mStatus = PERMISSION_DENIED;
2063 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002064 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002065 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002066 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002067 }
2068 } break;
2069 case RELEASE_AUDIO_PATCH: {
2070 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2071 ALOGV("AudioCommandThread() processing release audio patch");
2072 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2073 if (af == 0) {
2074 command->mStatus = PERMISSION_DENIED;
2075 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002076 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002077 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002078 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002079 }
2080 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002081 case UPDATE_AUDIOPORT_LIST: {
2082 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002083 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002084 if (svc == 0) {
2085 break;
2086 }
2087 mLock.unlock();
2088 svc->doOnAudioPortListUpdate();
2089 mLock.lock();
2090 }break;
2091 case UPDATE_AUDIOPATCH_LIST: {
2092 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002093 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002094 if (svc == 0) {
2095 break;
2096 }
2097 mLock.unlock();
2098 svc->doOnAudioPatchListUpdate();
2099 mLock.lock();
2100 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002101 case CHANGED_AUDIOVOLUMEGROUP: {
2102 AudioVolumeGroupData *data =
2103 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2104 ALOGV("AudioCommandThread() processing update audio volume group");
2105 svc = mService.promote();
2106 if (svc == 0) {
2107 break;
2108 }
2109 mLock.unlock();
2110 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2111 mLock.lock();
2112 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002113 case SET_AUDIOPORT_CONFIG: {
2114 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2115 ALOGV("AudioCommandThread() processing set port config");
2116 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2117 if (af == 0) {
2118 command->mStatus = PERMISSION_DENIED;
2119 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002120 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002121 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002122 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002123 }
2124 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002125 case DYN_POLICY_MIX_STATE_UPDATE: {
2126 DynPolicyMixStateUpdateData *data =
2127 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002128 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2129 data->mRegId.string(), data->mState);
2130 svc = mService.promote();
2131 if (svc == 0) {
2132 break;
2133 }
2134 mLock.unlock();
2135 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2136 mLock.lock();
2137 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002138 case RECORDING_CONFIGURATION_UPDATE: {
2139 RecordingConfigurationUpdateData *data =
2140 (RecordingConfigurationUpdateData *)command->mParam.get();
2141 ALOGV("AudioCommandThread() processing recording configuration update");
2142 svc = mService.promote();
2143 if (svc == 0) {
2144 break;
2145 }
2146 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002147 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002148 &data->mClientConfig, data->mClientEffects,
2149 &data->mDeviceConfig, data->mEffects,
2150 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002151 mLock.lock();
2152 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002153 case SET_EFFECT_SUSPENDED: {
2154 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2155 ALOGV("AudioCommandThread() processing set effect suspended");
2156 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2157 if (af != 0) {
2158 mLock.unlock();
2159 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2160 mLock.lock();
2161 }
2162 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002163 case AUDIO_MODULES_UPDATE: {
2164 ALOGV("AudioCommandThread() processing audio modules update");
2165 svc = mService.promote();
2166 if (svc == 0) {
2167 break;
2168 }
2169 mLock.unlock();
2170 svc->doOnNewAudioModulesAvailable();
2171 mLock.lock();
2172 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002173 case ROUTING_UPDATED: {
2174 ALOGV("AudioCommandThread() processing routing update");
2175 svc = mService.promote();
2176 if (svc == 0) {
2177 break;
2178 }
2179 mLock.unlock();
2180 svc->doOnRoutingUpdated();
2181 mLock.lock();
2182 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002183
Eric Laurented726cc2021-07-01 14:26:41 +02002184 case UPDATE_UID_STATES: {
2185 ALOGV("AudioCommandThread() processing updateUID states");
2186 svc = mService.promote();
2187 if (svc == 0) {
2188 break;
2189 }
2190 mLock.unlock();
2191 svc->updateUidStates();
2192 mLock.lock();
2193 } break;
2194
Eric Laurent15903592022-02-24 20:44:36 +01002195 case CHECK_SPATIALIZER_OUTPUT: {
2196 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002197 svc = mService.promote();
2198 if (svc == 0) {
2199 break;
2200 }
2201 mLock.unlock();
2202 svc->doOnCheckSpatializer();
2203 mLock.lock();
2204 } break;
2205
Eric Laurent15903592022-02-24 20:44:36 +01002206 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2207 ALOGV("AudioCommandThread() processing update spatializer tracks");
2208 svc = mService.promote();
2209 if (svc == 0) {
2210 break;
2211 }
2212 mLock.unlock();
2213 svc->doOnUpdateActiveSpatializerTracks();
2214 mLock.lock();
2215 } break;
2216
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002217 case VOL_RANGE_INIT_REQUEST: {
2218 ALOGV("AudioCommandThread() processing volume range init request");
2219 svc = mService.promote();
2220 if (svc == 0) {
2221 break;
2222 }
2223 mLock.unlock();
2224 svc->doOnVolumeRangeInitRequest();
2225 mLock.lock();
2226 } break;
2227
Mathias Agopian65ab4712010-07-14 17:59:35 -07002228 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002229 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002230 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002231 {
2232 Mutex::Autolock _l(command->mLock);
2233 if (command->mWaitStatus) {
2234 command->mWaitStatus = false;
2235 command->mCond.signal();
2236 }
2237 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002238 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002239 // release mLock before releasing strong reference on the service as
2240 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2241 // acquires mLock.
2242 mLock.unlock();
2243 svc.clear();
2244 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002245 } else {
2246 waitTime = mAudioCommands[0]->mTime - curTime;
2247 break;
2248 }
2249 }
Zach Janga754b4f2015-10-27 01:29:34 +00002250
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002251 // release delayed commands wake lock as many times as we made the queue is
2252 // empty during popping.
2253 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002254 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002255 }
2256
2257 // At this stage we have either an empty command queue or the first command in the queue
2258 // has a finite delay. So unless we are exiting it is safe to wait.
2259 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002260 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002261 if (waitTime == -1) {
2262 mWaitWorkCV.wait(mLock);
2263 } else {
2264 mWaitWorkCV.waitRelative(mLock, waitTime);
2265 }
Eric Laurent59a89232014-06-08 14:14:17 -07002266 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002267 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002268 // release delayed commands wake lock before quitting
2269 if (!mAudioCommands.isEmpty()) {
2270 release_wake_lock(mName.string());
2271 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002272 mLock.unlock();
2273 return false;
2274}
2275
2276status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2277{
2278 const size_t SIZE = 256;
2279 char buffer[SIZE];
2280 String8 result;
2281
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002282 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002283 if (!locked) {
2284 String8 result2(kCmdDeadlockedString);
2285 write(fd, result2.string(), result2.size());
2286 }
2287
2288 snprintf(buffer, SIZE, "- Commands:\n");
2289 result = String8(buffer);
2290 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002291 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002292 mAudioCommands[i]->dump(buffer, SIZE);
2293 result.append(buffer);
2294 }
2295 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002296 if (mLastCommand != 0) {
2297 mLastCommand->dump(buffer, SIZE);
2298 result.append(buffer);
2299 } else {
2300 result.append(" none\n");
2301 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002302
2303 write(fd, result.string(), result.size());
2304
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002305 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002306
2307 return NO_ERROR;
2308}
2309
Glenn Kastenfff6d712012-01-12 16:38:12 -08002310status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002311 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002312 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002313 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002314{
Eric Laurent0ede8922014-05-09 18:04:42 -07002315 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002316 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002317 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002318 data->mStream = stream;
2319 data->mVolume = volume;
2320 data->mIO = output;
2321 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002322 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002323 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002324 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002325 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002326}
2327
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002328status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002329 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002330 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002331{
Eric Laurent0ede8922014-05-09 18:04:42 -07002332 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002333 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002334 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002335 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002336 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002337 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002338 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002339 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002340 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002341 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002342}
2343
2344status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2345{
Eric Laurent0ede8922014-05-09 18:04:42 -07002346 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002347 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002348 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002349 data->mVolume = volume;
2350 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002351 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002352 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002353 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002354}
2355
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002356void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2357 audio_session_t sessionId,
2358 bool suspended)
2359{
2360 sp<AudioCommand> command = new AudioCommand();
2361 command->mCommand = SET_EFFECT_SUSPENDED;
2362 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2363 data->mEffectId = effectId;
2364 data->mSessionId = sessionId;
2365 data->mSuspended = suspended;
2366 command->mParam = data;
2367 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2368 effectId, sessionId, suspended);
2369 sendCommand(command);
2370}
2371
2372
Eric Laurentd7fe0862018-07-14 16:48:01 -07002373void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002374{
Eric Laurent0ede8922014-05-09 18:04:42 -07002375 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002376 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002377 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002378 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002379 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002380 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002381 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002382}
2383
Eric Laurentd7fe0862018-07-14 16:48:01 -07002384void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002385{
Eric Laurent0ede8922014-05-09 18:04:42 -07002386 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002387 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002388 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002389 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002390 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002391 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002392 sendCommand(command);
2393}
2394
Eric Laurent951f4552014-05-20 10:48:17 -07002395status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2396 const struct audio_patch *patch,
2397 audio_patch_handle_t *handle,
2398 int delayMs)
2399{
2400 status_t status = NO_ERROR;
2401
2402 sp<AudioCommand> command = new AudioCommand();
2403 command->mCommand = CREATE_AUDIO_PATCH;
2404 CreateAudioPatchData *data = new CreateAudioPatchData();
2405 data->mPatch = *patch;
2406 data->mHandle = *handle;
2407 command->mParam = data;
2408 command->mWaitStatus = true;
2409 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2410 status = sendCommand(command, delayMs);
2411 if (status == NO_ERROR) {
2412 *handle = data->mHandle;
2413 }
2414 return status;
2415}
2416
2417status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2418 int delayMs)
2419{
2420 sp<AudioCommand> command = new AudioCommand();
2421 command->mCommand = RELEASE_AUDIO_PATCH;
2422 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2423 data->mHandle = handle;
2424 command->mParam = data;
2425 command->mWaitStatus = true;
2426 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2427 return sendCommand(command, delayMs);
2428}
2429
Eric Laurentb52c1522014-05-20 11:27:36 -07002430void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2431{
2432 sp<AudioCommand> command = new AudioCommand();
2433 command->mCommand = UPDATE_AUDIOPORT_LIST;
2434 ALOGV("AudioCommandThread() adding update audio port list");
2435 sendCommand(command);
2436}
2437
Eric Laurented726cc2021-07-01 14:26:41 +02002438void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2439{
2440 sp<AudioCommand> command = new AudioCommand();
2441 command->mCommand = UPDATE_UID_STATES;
2442 ALOGV("AudioCommandThread() adding update UID states");
2443 sendCommand(command);
2444}
2445
Eric Laurentb52c1522014-05-20 11:27:36 -07002446void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2447{
2448 sp<AudioCommand>command = new AudioCommand();
2449 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2450 ALOGV("AudioCommandThread() adding update audio patch list");
2451 sendCommand(command);
2452}
2453
François Gaffiecfe17322018-11-07 13:41:29 +01002454void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2455 int flags)
2456{
2457 sp<AudioCommand>command = new AudioCommand();
2458 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2459 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2460 data->mGroup = group;
2461 data->mFlags = flags;
2462 command->mParam = data;
2463 ALOGV("AudioCommandThread() adding audio volume group changed");
2464 sendCommand(command);
2465}
2466
Eric Laurente1715a42014-05-20 11:30:42 -07002467status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2468 const struct audio_port_config *config, int delayMs)
2469{
2470 sp<AudioCommand> command = new AudioCommand();
2471 command->mCommand = SET_AUDIOPORT_CONFIG;
2472 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2473 data->mConfig = *config;
2474 command->mParam = data;
2475 command->mWaitStatus = true;
2476 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2477 return sendCommand(command, delayMs);
2478}
2479
Jean-Michel Trivide801052015-04-14 19:10:14 -07002480void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002481 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002482{
2483 sp<AudioCommand> command = new AudioCommand();
2484 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2485 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2486 data->mRegId = regId;
2487 data->mState = state;
2488 command->mParam = data;
2489 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2490 regId.string(), state);
2491 sendCommand(command);
2492}
2493
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002494void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002495 int event,
2496 const record_client_info_t *clientInfo,
2497 const audio_config_base_t *clientConfig,
2498 std::vector<effect_descriptor_t> clientEffects,
2499 const audio_config_base_t *deviceConfig,
2500 std::vector<effect_descriptor_t> effects,
2501 audio_patch_handle_t patchHandle,
2502 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002503{
2504 sp<AudioCommand>command = new AudioCommand();
2505 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2506 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2507 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002508 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002509 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002510 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002511 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002512 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002513 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002514 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002515 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002516 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2517 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002518 sendCommand(command);
2519}
2520
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002521void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2522{
2523 sp<AudioCommand> command = new AudioCommand();
2524 command->mCommand = AUDIO_MODULES_UPDATE;
2525 sendCommand(command);
2526}
2527
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002528void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2529{
2530 sp<AudioCommand>command = new AudioCommand();
2531 command->mCommand = ROUTING_UPDATED;
2532 ALOGV("AudioCommandThread() adding routing update");
2533 sendCommand(command);
2534}
2535
Eric Laurent81dd0f52021-07-05 11:54:40 +02002536void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2537{
2538 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002539 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002540 ALOGV("AudioCommandThread() adding check spatializer");
2541 sendCommand(command);
2542}
2543
Eric Laurent15903592022-02-24 20:44:36 +01002544void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2545{
2546 sp<AudioCommand>command = new AudioCommand();
2547 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2548 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2549 sendCommand(command);
2550}
2551
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002552void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2553{
2554 sp<AudioCommand>command = new AudioCommand();
2555 command->mCommand = VOL_RANGE_INIT_REQUEST;
2556 ALOGV("AudioCommandThread() adding volume range init request");
2557 sendCommand(command);
2558}
2559
Eric Laurent0ede8922014-05-09 18:04:42 -07002560status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2561{
2562 {
2563 Mutex::Autolock _l(mLock);
2564 insertCommand_l(command, delayMs);
2565 mWaitWorkCV.signal();
2566 }
2567 Mutex::Autolock _l(command->mLock);
2568 while (command->mWaitStatus) {
2569 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2570 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2571 command->mStatus = TIMED_OUT;
2572 command->mWaitStatus = false;
2573 }
2574 }
2575 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002576}
2577
Mathias Agopian65ab4712010-07-14 17:59:35 -07002578// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002579void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002580{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002581 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002582 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002583 command->mTime = systemTime() + milliseconds(delayMs);
2584
2585 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002586 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002587 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2588 }
2589
2590 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002591 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002592 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002593 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2594 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002595
2596 // create audio patch or release audio patch commands are equivalent
2597 // with regard to filtering
2598 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2599 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2600 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2601 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2602 continue;
2603 }
2604 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002605
2606 switch (command->mCommand) {
2607 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002608 ParametersData *data = (ParametersData *)command->mParam.get();
2609 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002610 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002611 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002612 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002613 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2614 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2615 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002616 String8 key;
2617 String8 value;
2618 param.getAt(j, key, value);
2619 for (size_t k = 0; k < param2.size(); k++) {
2620 String8 key2;
2621 String8 value2;
2622 param2.getAt(k, key2, value2);
2623 if (key2 == key) {
2624 param2.remove(key2);
2625 ALOGV("Filtering out parameter %s", key2.string());
2626 break;
2627 }
2628 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002629 }
2630 // if all keys have been filtered out, remove the command.
2631 // otherwise, update the key value pairs
2632 if (param2.size() == 0) {
2633 removedCommands.add(command2);
2634 } else {
2635 data2->mKeyValuePairs = param2.toString();
2636 }
Eric Laurent21e54562013-09-23 12:08:05 -07002637 command->mTime = command2->mTime;
2638 // force delayMs to non 0 so that code below does not request to wait for
2639 // command status as the command is now delayed
2640 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002641 } break;
2642
2643 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002644 VolumeData *data = (VolumeData *)command->mParam.get();
2645 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002646 if (data->mIO != data2->mIO) break;
2647 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002648 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002649 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002650 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002651 command->mTime = command2->mTime;
2652 // force delayMs to non 0 so that code below does not request to wait for
2653 // command status as the command is now delayed
2654 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002655 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002656
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002657 case SET_VOICE_VOLUME: {
2658 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2659 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2660 ALOGV("Filtering out voice volume command value %f replaced by %f",
2661 data2->mVolume, data->mVolume);
2662 removedCommands.add(command2);
2663 command->mTime = command2->mTime;
2664 // force delayMs to non 0 so that code below does not request to wait for
2665 // command status as the command is now delayed
2666 delayMs = 1;
2667 } break;
2668
Eric Laurente45b48a2014-09-04 16:40:57 -07002669 case CREATE_AUDIO_PATCH:
2670 case RELEASE_AUDIO_PATCH: {
2671 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002672 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002673 if (command->mCommand == CREATE_AUDIO_PATCH) {
2674 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002675 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002676 } else {
2677 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002678 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002679 }
2680 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002681 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002682 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2683 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002684 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002685 } else {
2686 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002687 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002688 }
2689 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002690 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2691 same output. */
2692 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2693 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2694 bool isOutputDiff = false;
2695 if (patch.num_sources == patch2.num_sources) {
2696 for (unsigned count = 0; count < patch.num_sources; count++) {
2697 if (patch.sources[count].id != patch2.sources[count].id) {
2698 isOutputDiff = true;
2699 break;
2700 }
2701 }
2702 if (isOutputDiff)
2703 break;
2704 }
2705 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002706 ALOGV("Filtering out %s audio patch command for handle %d",
2707 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2708 removedCommands.add(command2);
2709 command->mTime = command2->mTime;
2710 // force delayMs to non 0 so that code below does not request to wait for
2711 // command status as the command is now delayed
2712 delayMs = 1;
2713 } break;
2714
Jean-Michel Trivide801052015-04-14 19:10:14 -07002715 case DYN_POLICY_MIX_STATE_UPDATE: {
2716
2717 } break;
2718
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002719 case RECORDING_CONFIGURATION_UPDATE: {
2720
2721 } break;
2722
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002723 case ROUTING_UPDATED: {
2724
2725 } break;
2726
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002727 case VOL_RANGE_INIT_REQUEST: {
2728 // command may come from different requests, do not filter
2729 } break;
2730
Mathias Agopian65ab4712010-07-14 17:59:35 -07002731 default:
2732 break;
2733 }
2734 }
2735
2736 // remove filtered commands
2737 for (size_t j = 0; j < removedCommands.size(); j++) {
2738 // removed commands always have time stamps greater than current command
2739 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002740 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002741 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002742 mAudioCommands.removeAt(k);
2743 break;
2744 }
2745 }
2746 }
2747 removedCommands.clear();
2748
Eric Laurentaa79bef2015-01-15 14:33:51 -08002749 // Disable wait for status if delay is not 0.
2750 // Except for create audio patch command because the returned patch handle
2751 // is needed by audio policy manager
2752 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002753 command->mWaitStatus = false;
2754 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002755
Mathias Agopian65ab4712010-07-14 17:59:35 -07002756 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002757 ALOGV("inserting command: %d at index %zd, num commands %zu",
2758 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002759 mAudioCommands.insertAt(command, i + 1);
2760}
2761
2762void AudioPolicyService::AudioCommandThread::exit()
2763{
Steve Block3856b092011-10-20 11:56:00 +01002764 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002765 {
2766 AutoMutex _l(mLock);
2767 requestExit();
2768 mWaitWorkCV.signal();
2769 }
Zach Janga754b4f2015-10-27 01:29:34 +00002770 // Note that we can call it from the thread loop if all other references have been released
2771 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002772 requestExitAndWait();
2773}
2774
2775void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2776{
2777 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2778 mCommand,
2779 (int)ns2s(mTime),
2780 (int)ns2ms(mTime)%1000,
2781 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002782 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002783}
2784
Dima Zavinfce7a472011-04-19 22:30:36 -07002785/******* helpers for the service_ops callbacks defined below *********/
2786void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2787 const char *keyValuePairs,
2788 int delayMs)
2789{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002790 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002791 delayMs);
2792}
2793
2794int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2795 float volume,
2796 audio_io_handle_t output,
2797 int delayMs)
2798{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002799 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002800 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002801}
2802
Dima Zavinfce7a472011-04-19 22:30:36 -07002803int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2804{
2805 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2806}
2807
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002808void AudioPolicyService::setEffectSuspended(int effectId,
2809 audio_session_t sessionId,
2810 bool suspended)
2811{
2812 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2813}
2814
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002815Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002816{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002817 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002818 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002819}
2820
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002821
Dima Zavinfce7a472011-04-19 22:30:36 -07002822extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002823audio_module_handle_t aps_load_hw_module(void *service __unused,
2824 const char *name);
2825audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002826 audio_devices_t *pDevices,
2827 uint32_t *pSamplingRate,
2828 audio_format_t *pFormat,
2829 audio_channel_mask_t *pChannelMask,
2830 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002831 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002832
Eric Laurent2d388ec2014-03-07 13:25:54 -08002833audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002834 audio_module_handle_t module,
2835 audio_devices_t *pDevices,
2836 uint32_t *pSamplingRate,
2837 audio_format_t *pFormat,
2838 audio_channel_mask_t *pChannelMask,
2839 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002840 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002841 const audio_offload_info_t *offloadInfo);
2842audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002843 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002844 audio_io_handle_t output2);
2845int aps_close_output(void *service __unused, audio_io_handle_t output);
2846int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2847int aps_restore_output(void *service __unused, audio_io_handle_t output);
2848audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002849 audio_devices_t *pDevices,
2850 uint32_t *pSamplingRate,
2851 audio_format_t *pFormat,
2852 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002853 audio_in_acoustics_t acoustics __unused);
2854audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002855 audio_module_handle_t module,
2856 audio_devices_t *pDevices,
2857 uint32_t *pSamplingRate,
2858 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002859 audio_channel_mask_t *pChannelMask);
2860int aps_close_input(void *service __unused, audio_io_handle_t input);
2861int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002862int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002863 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002864 audio_io_handle_t dst_output);
2865char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2866 const char *keys);
2867void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2868 const char *kv_pairs, int delay_ms);
2869int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002870 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002871 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002872int aps_set_voice_volume(void *service, float volume, int delay_ms);
2873};
Dima Zavinfce7a472011-04-19 22:30:36 -07002874
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002875} // namespace android