blob: 3cd74a0093d6c5abfcc23c3fbd5e6a4b14dd7d50 [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) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000148BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800149BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
150BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
151BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
152BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
155BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
156BINDER_METHOD_ENTRY(getSpatializer) \
157BINDER_METHOD_ENTRY(canBeSpatialized) \
158BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000159BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
160BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
161BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
162BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
163BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Andy Hungc747c532022-03-07 21:41:14 -0800164
165// singleton for Binder Method Statistics for IAudioPolicyService
166static auto& getIAudioPolicyServiceStatistics() {
167 using Code = int;
168
169#pragma push_macro("BINDER_METHOD_ENTRY")
170#undef BINDER_METHOD_ENTRY
171#define BINDER_METHOD_ENTRY(ENTRY) \
172 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
173
174 static mediautils::MethodStatistics<Code> methodStatistics{
175 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
176 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
177 };
178#pragma pop_macro("BINDER_METHOD_ENTRY")
179
180 return methodStatistics;
181}
182
Mathias Agopian65ab4712010-07-14 17:59:35 -0700183// ----------------------------------------------------------------------------
184
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530185static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
186{
187 AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);
188 status_t status = apm->initialize();
189 if (status != NO_ERROR) {
190 delete apm;
191 apm = nullptr;
192 }
193 return apm;
194}
195
196static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
197{
198 delete interface;
199}
200// ----------------------------------------------------------------------------
201
Mathias Agopian65ab4712010-07-14 17:59:35 -0700202AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700203 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700204 mAudioPolicyManager(NULL),
205 mAudioPolicyClient(NULL),
206 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530207 mCaptureStateNotifier(false),
208 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100209 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
210 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800211 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530212}
213
214void AudioPolicyService::loadAudioPolicyManager()
215{
216 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
217 if (mLibraryHandle != nullptr) {
218 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
219 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
220 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
221 const char *lastError = dlerror();
222 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
223 __func__, lastError != nullptr ? lastError : "no error");
224
225 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
226 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
227 lastError = dlerror();
228 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
229 __func__, lastError != nullptr ? lastError : "no error");
230 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
231 unloadAudioPolicyManager();
232 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
233 }
234 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700235}
236
237void AudioPolicyService::onFirstRef()
238{
Andy Hungd47aca22022-03-15 11:50:51 -0700239 // Log an AudioPolicy "constructor" mediametrics event on first ref.
240 // This records the time it takes to load the audio modules and devices.
241 mediametrics::Defer defer([beginNs = systemTime()] {
242 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
243 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
244 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
245 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700246 {
247 Mutex::Autolock _l(mLock);
Eric Laurent93575202011-01-18 18:39:02 -0800248
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700249 // start audio commands thread
250 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
251 // start output activity command thread
252 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700253
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700254 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530255
256 loadAudioPolicyManager();
257 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700258 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200259
bryant_liuba2b4392014-06-11 16:49:30 +0800260 // load audio processing modules
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000261 sp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();
262 sp<UidPolicy> uidPolicy = new UidPolicy(this);
263 sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700264 {
265 Mutex::Autolock _l(mLock);
266 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000267 mUidPolicy = uidPolicy;
268 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700269 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000270 uidPolicy->registerSelf();
271 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200272
Eric Laurent81dd0f52021-07-05 11:54:40 +0200273 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200274 if (mAudioPolicyManager != nullptr) {
275 Mutex::Autolock _l(mLock);
276 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
277 AudioDeviceTypeAddrVector devices;
278 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
279 if (hasSpatializer) {
280 mSpatializer = Spatializer::create(this);
281 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700282 if (mSpatializer == nullptr) {
283 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
284 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
285 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
286 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200287 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200288 AudioSystem::audioPolicyReady();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700289}
290
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530291void AudioPolicyService::unloadAudioPolicyManager()
292{
293 ALOGV("%s ", __func__);
294 if (mLibraryHandle != nullptr) {
295 dlclose(mLibraryHandle);
296 }
297 mLibraryHandle = nullptr;
298 mCreateAudioPolicyManager = nullptr;
299 mDestroyAudioPolicyManager = nullptr;
300}
301
Mathias Agopian65ab4712010-07-14 17:59:35 -0700302AudioPolicyService::~AudioPolicyService()
303{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700304 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700305 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700306
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530307 mDestroyAudioPolicyManager(mAudioPolicyManager);
308 unloadAudioPolicyManager();
309
Eric Laurentdce54a12014-03-10 12:19:46 -0700310 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700311
312 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800313 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800314
315 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800316 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000317
318 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800319 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700320}
321
322// A notification client is always registered by AudioSystem when the client process
323// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800324Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700325{
Eric Laurent12590252015-08-21 18:40:20 -0700326 if (client == 0) {
327 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800328 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700329 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800330 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700331
332 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800333 pid_t pid = IPCThreadState::self()->getCallingPid();
334 int64_t token = ((int64_t)uid<<32) | pid;
335
336 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700337 sp<NotificationClient> notificationClient = new NotificationClient(this,
338 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800339 uid,
340 pid);
341 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700342
luochaojiang908c7d72018-06-21 14:58:04 +0800343 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700344
Marco Nelissenf8880202014-11-14 07:58:25 -0800345 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700346 binder->linkToDeath(notificationClient);
347 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800348 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700349}
350
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800351Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700352{
353 Mutex::Autolock _l(mNotificationClientsLock);
354
355 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800356 pid_t pid = IPCThreadState::self()->getCallingPid();
357 int64_t token = ((int64_t)uid<<32) | pid;
358
359 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800360 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700361 }
luochaojiang908c7d72018-06-21 14:58:04 +0800362 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800363 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700364}
365
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800366Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100367{
368 Mutex::Autolock _l(mNotificationClientsLock);
369
370 uid_t uid = IPCThreadState::self()->getCallingUid();
371 pid_t pid = IPCThreadState::self()->getCallingPid();
372 int64_t token = ((int64_t)uid<<32) | pid;
373
374 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800375 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100376 }
377 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800378 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100379}
380
Eric Laurentb52c1522014-05-20 11:27:36 -0700381// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800382void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700383{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000384 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800385 {
386 Mutex::Autolock _l(mNotificationClientsLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800387 int64_t token = ((int64_t)uid<<32) | pid;
388 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800389 for (size_t i = 0; i < mNotificationClients.size(); i++) {
390 if (mNotificationClients.valueAt(i)->uid() == uid) {
391 hasSameUid = true;
392 break;
393 }
394 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000395 }
396 {
397 Mutex::Autolock _l(mLock);
luochaojiang908c7d72018-06-21 14:58:04 +0800398 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700399 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700400 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700401 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800402 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700403}
404
405void AudioPolicyService::onAudioPortListUpdate()
406{
407 mOutputCommandThread->updateAudioPortListCommand();
408}
409
410void AudioPolicyService::doOnAudioPortListUpdate()
411{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800412 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700413 for (size_t i = 0; i < mNotificationClients.size(); i++) {
414 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
415 }
416}
417
418void AudioPolicyService::onAudioPatchListUpdate()
419{
420 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700421}
422
Eric Laurentb52c1522014-05-20 11:27:36 -0700423void AudioPolicyService::doOnAudioPatchListUpdate()
424{
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800425 Mutex::Autolock _l(mNotificationClientsLock);
Eric Laurentb52c1522014-05-20 11:27:36 -0700426 for (size_t i = 0; i < mNotificationClients.size(); i++) {
427 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
428 }
429}
430
François Gaffiecfe17322018-11-07 13:41:29 +0100431void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
432{
433 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
434}
435
436void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
437{
438 Mutex::Autolock _l(mNotificationClientsLock);
439 for (size_t i = 0; i < mNotificationClients.size(); i++) {
440 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
441 }
442}
443
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700444void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700445{
446 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
447 regId.string(), state);
448 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
449}
450
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700451void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700452{
453 Mutex::Autolock _l(mNotificationClientsLock);
454 for (size_t i = 0; i < mNotificationClients.size(); i++) {
455 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
456 }
457}
458
Eric Laurenta9f86652018-11-28 17:23:11 -0800459void AudioPolicyService::onRecordingConfigurationUpdate(
460 int event,
461 const record_client_info_t *clientInfo,
462 const audio_config_base_t *clientConfig,
463 std::vector<effect_descriptor_t> clientEffects,
464 const audio_config_base_t *deviceConfig,
465 std::vector<effect_descriptor_t> effects,
466 audio_patch_handle_t patchHandle,
467 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800468{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800469 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800470 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800471}
472
Eric Laurenta9f86652018-11-28 17:23:11 -0800473void AudioPolicyService::doOnRecordingConfigurationUpdate(
474 int event,
475 const record_client_info_t *clientInfo,
476 const audio_config_base_t *clientConfig,
477 std::vector<effect_descriptor_t> clientEffects,
478 const audio_config_base_t *deviceConfig,
479 std::vector<effect_descriptor_t> effects,
480 audio_patch_handle_t patchHandle,
481 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800482{
483 Mutex::Autolock _l(mNotificationClientsLock);
484 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800485 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800486 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800487 }
488}
489
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700490void AudioPolicyService::onRoutingUpdated()
491{
492 mOutputCommandThread->routingChangedCommand();
493}
494
495void AudioPolicyService::doOnRoutingUpdated()
496{
497 Mutex::Autolock _l(mNotificationClientsLock);
498 for (size_t i = 0; i < mNotificationClients.size(); i++) {
499 mNotificationClients.valueAt(i)->onRoutingUpdated();
500 }
501}
502
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000503void AudioPolicyService::onVolumeRangeInitRequest()
504{
505 mOutputCommandThread->volRangeInitReqCommand();
506}
507
508void AudioPolicyService::doOnVolumeRangeInitRequest()
509{
510 Mutex::Autolock _l(mNotificationClientsLock);
511 for (size_t i = 0; i < mNotificationClients.size(); i++) {
512 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
513 }
514}
515
Eric Laurent81dd0f52021-07-05 11:54:40 +0200516void AudioPolicyService::onCheckSpatializer()
517{
518 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200519 onCheckSpatializer_l();
520}
521
522void AudioPolicyService::onCheckSpatializer_l()
523{
524 if (mSpatializer != nullptr) {
525 mOutputCommandThread->checkSpatializerCommand();
526 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200527}
528
529void AudioPolicyService::doOnCheckSpatializer()
530{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200531 ALOGV("%s mSpatializer %p level %d",
532 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200533
Eric Laurent39095982021-08-24 18:29:27 +0200534 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200535 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Eric Laurent39095982021-08-24 18:29:27 +0200536 if (mSpatializer->getLevel() != media::SpatializationLevel::NONE) {
537 audio_io_handle_t currentOutput = mSpatializer->getOutput();
538 audio_io_handle_t newOutput;
539 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
540 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200541
542 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200543 status_t status =
544 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100545 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
546 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200547 if (status == NO_ERROR && currentOutput == newOutput) {
548 return;
549 }
Eric Laurent15903592022-02-24 20:44:36 +0100550 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Eric Laurent39095982021-08-24 18:29:27 +0200551 mLock.unlock();
552 // It is OK to call detachOutput() is none is already attached.
553 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200554 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
555 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200556 }
Eric Laurent39095982021-08-24 18:29:27 +0200557 mLock.lock();
558 if (status != NO_ERROR) {
559 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
560 }
561 } else if (mSpatializer->getLevel() == media::SpatializationLevel::NONE
562 && mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200563 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200564
Eric Laurent39095982021-08-24 18:29:27 +0200565 if (output != AUDIO_IO_HANDLE_NONE) {
Eric Laurent21270b62022-07-04 15:11:29 +0200566 Mutex::Autolock _l(mLock);
Eric Laurent39095982021-08-24 18:29:27 +0200567 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200568 }
569 }
570 }
571}
572
Eric Laurent11094172022-04-05 18:27:42 +0200573size_t AudioPolicyService::countActiveClientsOnOutput_l(
574 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100575 size_t count = 0;
576 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
577 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200578 if (client->io == output && client->active
579 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100580 count++;
581 }
582 }
583 return count;
584}
585
586void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
587 if (mSpatializer == nullptr) {
588 return;
589 }
590 mOutputCommandThread->updateActiveSpatializerTracksCommand();
591}
592
593void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
594{
Eric Laurent21270b62022-07-04 15:11:29 +0200595 if (mSpatializer == nullptr) {
596 return;
597 }
598 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200599 size_t activeClients;
600 {
601 Mutex::Autolock _l(mLock);
Eric Laurent21270b62022-07-04 15:11:29 +0200602 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100603 }
Eric Laurent21270b62022-07-04 15:11:29 +0200604 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100605}
606
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800607status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
608 audio_patch_handle_t *handle,
609 int delayMs)
610{
611 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
612}
613
614status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
615 int delayMs)
616{
617 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
618}
619
Eric Laurente1715a42014-05-20 11:30:42 -0700620status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
621 int delayMs)
622{
623 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
624}
625
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800626AudioPolicyService::NotificationClient::NotificationClient(
627 const sp<AudioPolicyService>& service,
628 const sp<media::IAudioPolicyServiceClient>& client,
629 uid_t uid,
630 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800631 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100632 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700633{
634}
635
636AudioPolicyService::NotificationClient::~NotificationClient()
637{
638}
639
640void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
641{
642 sp<NotificationClient> keep(this);
643 sp<AudioPolicyService> service = mService.promote();
644 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800645 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700646 }
647}
648
649void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
650{
Eric Laurente8726fe2015-06-26 09:39:24 -0700651 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700652 mAudioPolicyServiceClient->onAudioPortListUpdate();
653 }
654}
655
656void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
657{
Eric Laurente8726fe2015-06-26 09:39:24 -0700658 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700659 mAudioPolicyServiceClient->onAudioPatchListUpdate();
660 }
661}
Eric Laurent57dae992011-07-24 13:36:09 -0700662
Pattydd807582021-11-04 21:01:03 +0800663void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100664 int flags)
665{
666 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
667 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
668 }
669}
670
671
Jean-Michel Trivide801052015-04-14 19:10:14 -0700672void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700673 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700674{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700675 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800676 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
677 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800678 }
679}
680
681void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800682 int event,
683 const record_client_info_t *clientInfo,
684 const audio_config_base_t *clientConfig,
685 std::vector<effect_descriptor_t> clientEffects,
686 const audio_config_base_t *deviceConfig,
687 std::vector<effect_descriptor_t> effects,
688 audio_patch_handle_t patchHandle,
689 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800690{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700691 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800692 status_t status = [&]() -> status_t {
693 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
694 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
695 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700696 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700697 legacy2aidl_audio_config_base_t_AudioConfigBase(
698 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800699 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
700 convertContainer<std::vector<media::EffectDescriptor>>(
701 clientEffects,
702 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700703 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700704 legacy2aidl_audio_config_base_t_AudioConfigBase(
705 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800706 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
707 convertContainer<std::vector<media::EffectDescriptor>>(
708 effects,
709 legacy2aidl_effect_descriptor_t_EffectDescriptor));
710 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
711 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700712 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
713 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800714 return aidl_utils::statusTFromBinderStatus(
715 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
716 clientInfoAidl,
717 clientConfigAidl,
718 clientEffectsAidl,
719 deviceConfigAidl,
720 effectsAidl,
721 patchHandleAidl,
722 sourceAidl));
723 }();
724 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700725 }
726}
727
Eric Laurente8726fe2015-06-26 09:39:24 -0700728void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
729{
730 mAudioPortCallbacksEnabled = enabled;
731}
732
François Gaffiecfe17322018-11-07 13:41:29 +0100733void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
734{
735 mAudioVolumeGroupCallbacksEnabled = enabled;
736}
Eric Laurente8726fe2015-06-26 09:39:24 -0700737
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700738void AudioPolicyService::NotificationClient::onRoutingUpdated()
739{
740 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
741 mAudioPolicyServiceClient->onRoutingUpdated();
742 }
743}
744
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000745void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
746{
747 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
748 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
749 }
750}
751
Mathias Agopian65ab4712010-07-14 17:59:35 -0700752void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700753 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700754 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700755}
756
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000757static bool dumpTryLock(Mutex& mutex) ACQUIRE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mathias Agopian65ab4712010-07-14 17:59:35 -0700758{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000759 return mutex.timedLock(kDumpLockTimeoutNs) == NO_ERROR;
760}
761
762static void dumpReleaseLock(Mutex& mutex, bool locked) RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
763{
764 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700765}
766
767status_t AudioPolicyService::dumpInternals(int fd)
768{
769 const size_t SIZE = 256;
770 char buffer[SIZE];
771 String8 result;
772
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000773 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800774 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000775 std::stringstream msg;
776 size_t i = 0;
777 for (auto usage : mSupportedSystemUsages) {
778 if (i++ != 0) msg << ", ";
779 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
780 msg << strUsage;
781 } else {
782 msg << usage << " (unknown)";
783 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800784 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000785 if (i == 0) {
786 msg << "None";
787 }
788 msg << std::endl;
789 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800790
Mathias Agopian65ab4712010-07-14 17:59:35 -0700791 write(fd, result.string(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800792
793 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700794 return NO_ERROR;
795}
796
Eric Laurente8c8b432018-10-17 10:08:02 -0700797void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800798{
Eric Laurente8c8b432018-10-17 10:08:02 -0700799 Mutex::Autolock _l(mLock);
800 updateUidStates_l();
801}
802
803void AudioPolicyService::updateUidStates_l()
804{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800805// Go over all active clients and allow capture (does not force silence) in the
806// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800807// The client is in the active assistant list
808// AND is TOP
809// AND an accessibility service is TOP
810// AND source is either VOICE_RECOGNITION OR HOTWORD
811// OR there is no active privacy sensitive capture or call
812// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
813// AND source is VOICE_RECOGNITION OR HOTWORD
814// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800815// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700816// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800817// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800818// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800819// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
820// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800821// OR The client is an accessibility service
822// AND Is on TOP
823// AND the source is VOICE_RECOGNITION or HOTWORD
824// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700825// AND there is no active privacy sensitive capture or call
826// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800827// AND is on TOP
828// AND the source is VOICE_RECOGNITION or HOTWORD
829// OR the client source is virtual (remote submix, call audio TX or RX...)
830// OR the client source is HOTWORD
831// AND is on TOP
832// OR all active clients are using HOTWORD source
833// AND no call is active
834// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
835// OR the client is the current InputMethodService
836// AND a RTT call is active AND the source is VOICE_RECOGNITION
837// OR Any client
838// AND The assistant is not on TOP
839// AND is on TOP or latest started
840// AND there is no active privacy sensitive capture or call
841// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800842
Eric Laurent4e947da2019-10-17 15:24:06 -0700843
Eric Laurent4eb58f12018-12-07 16:41:02 -0800844 sp<AudioRecordClient> topActive;
845 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800846 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700847 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800848 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700849
Eric Laurenta46bedb2018-12-07 18:01:26 -0800850 nsecs_t topStartNs = 0;
851 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800852 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800853 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800854 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800855 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
856 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800857 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800858 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700859 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800860 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
861 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700862 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700863 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700864 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800865
Michael Groovercfd28302018-12-11 19:16:46 -0800866 // if Sensor Privacy is enabled then all recordings should be silenced.
867 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
868 silenceAllRecordings_l();
869 return;
870 }
871
Eric Laurente8c8b432018-10-17 10:08:02 -0700872 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
873 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000874 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
875 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800876 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700877 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800878 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700879
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700880 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700881 // clients which app is in IDLE state are not eligible for top active or
882 // latest active
883 if (appState == APP_STATE_IDLE) {
884 continue;
885 }
886
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700887 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700888 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800889 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700890 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700891 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800892 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800893 bool isPrivacySensitive =
894 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700895
Eric Laurentc21d5692020-02-25 10:24:36 -0800896 if (appState == APP_STATE_TOP) {
897 if (isPrivacySensitive) {
898 if (current->startTimeNs > topSensitiveStartNs) {
899 topSensitiveActive = current;
900 topSensitiveStartNs = current->startTimeNs;
901 }
902 } else {
903 if (current->startTimeNs > topStartNs) {
904 topActive = current;
905 topStartNs = current->startTimeNs;
906 }
907 }
908 if (isAssistant) {
909 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800910 if (isActiveAssistant) {
911 useActiveAssistantList = true;
912 } else if (!useActiveAssistantList) {
913 if (current->startTimeNs > latestAssistantStartNs) {
914 latestActiveAssistant = current;
915 latestAssistantStartNs = current->startTimeNs;
916 }
917 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800918 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800919 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800920 // Clients capturing for HOTWORD are not considered
921 // for latest active to avoid masking regular clients started before
922 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
923 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
924 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700925 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
926 // is marked latest sensitive active even if another app qualifies.
927 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700928 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700929 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700930 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000931 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700932 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700933 latestSensitiveActiveOrComm = current;
934 latestSensitiveStartNs = current->startTimeNs;
935 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800936 }
937 isSensitiveActive = true;
938 } else {
939 if (current->startTimeNs > latestStartNs) {
940 latestActive = current;
941 latestStartNs = current->startTimeNs;
942 }
943 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800944 }
945 }
Eric Laurent4e947da2019-10-17 15:24:06 -0700946 if (current->attributes.source != AUDIO_SOURCE_HOTWORD) {
947 onlyHotwordActive = false;
948 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100949 if (currentUid == mPhoneStateOwnerUid &&
950 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700951 isPhoneStateOwnerActive = true;
952 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800953 }
954
Eric Laurent1ff16a72019-03-14 18:35:04 -0700955 // if no active client with UI on Top, consider latest active as top
956 if (topActive == nullptr) {
957 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800958 topStartNs = latestStartNs;
959 }
960 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700961 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800962 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700963 } else if (latestSensitiveActiveOrComm != nullptr) {
964 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
965 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700966 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000967 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700968 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700969 topSensitiveActive = latestSensitiveActiveOrComm;
970 topSensitiveStartNs = latestSensitiveStartNs;
971 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800972 }
973
974 // If both privacy sensitive and regular capture are active:
975 // if the regular capture is privileged
976 // allow concurrency
977 // else
978 // favor the privacy sensitive case
979 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -0700980 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -0800981 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800982 }
983
984 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
985 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700986 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000987 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700988 if (!current->active) {
989 continue;
990 }
991
Eric Laurent4eb58f12018-12-07 16:41:02 -0800992 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700993 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000994 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700995 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +0000996 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800997 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
998 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -0800999
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001000 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mLock) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001001 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001002 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001003 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001004 bool canCaptureCommunication = recordClient->canCaptureOutput
1005 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001006 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001007 return !(isInCall && !canCaptureCall)
1008 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001009 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001010
1011 // By default allow capture if:
1012 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001013 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001014 // AND there is no active privacy sensitive capture or call
1015 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001016 bool allowSensitiveCapture =
1017 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001018 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001019 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001020 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001021 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001022
Eric Laurented726cc2021-07-01 14:26:41 +02001023 if (!current->hasOp()) {
1024 // Never allow capture if app op is denied
1025 allowCapture = false;
1026 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001027 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1028 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001029 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001030 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001031 // Active assistant list is not being used
1032 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001033 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001034 // OR there is no active privacy sensitive capture or call
1035 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1036 // AND is latest TOP assistant AND
1037 // uses VOICE_RECOGNITION OR uses HOTWORD
1038 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001039 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001040 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001041 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001042 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001043 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001044 && canCaptureIfInCallOrCommunication(current)) {
1045 if (isTopOrLatestAssistant
1046 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1047 || source == AUDIO_SOURCE_HOTWORD)) {
1048 allowCapture = true;
1049 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1050 allowCapture = true;
1051 }
1052 }
1053 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1054 // For assistant on active list and on top allow capture if:
1055 // An accessibility service is on TOP
1056 // AND the source is VOICE_RECOGNITION or HOTWORD
1057 // OR there is no active privacy sensitive capture or call
1058 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1059 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1060 if (isA11yOnTop) {
1061 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1062 allowCapture = true;
1063 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001064 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001065 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001066 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1067 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001068 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001069 }
1070 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001071 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001072 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001073 // The assistant is not on TOP
1074 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001075 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001076 // OR
1077 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1078 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001079 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001080 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001081 allowCapture = true;
1082 }
Eric Laurent589171c2019-07-25 18:04:29 -07001083 if (isA11yOnTop) {
1084 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1085 allowCapture = true;
1086 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001087 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001088 } else if (source == AUDIO_SOURCE_HOTWORD) {
1089 // For HOTWORD source allow capture when not on TOP if:
1090 // All active clients are using HOTWORD source
1091 // AND no call is active
1092 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001093 if (onlyHotwordActive
1094 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001095 allowCapture = true;
1096 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001097 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001098 // For current InputMethodService allow capture if:
1099 // A RTT call is active AND the source is VOICE_RECOGNITION
1100 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1101 allowCapture = true;
1102 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001103 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001104 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001105 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001106 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001107 }
1108}
1109
Michael Groovercfd28302018-12-11 19:16:46 -08001110void AudioPolicyService::silenceAllRecordings_l() {
1111 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1112 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001113 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001114 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001115 }
Michael Groovercfd28302018-12-11 19:16:46 -08001116 }
1117}
1118
Eric Laurente8c8b432018-10-17 10:08:02 -07001119/* static */
1120app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001121
1122 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001123 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001124 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1125 // include persistent services
1126 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001127 }
1128 return APP_STATE_FOREGROUND;
1129}
1130
Eric Laurent4eb58f12018-12-07 16:41:02 -08001131/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001132bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001133{
1134 switch (source) {
1135 case AUDIO_SOURCE_VOICE_UPLINK:
1136 case AUDIO_SOURCE_VOICE_DOWNLINK:
1137 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001138 case AUDIO_SOURCE_REMOTE_SUBMIX:
1139 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001140 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001141 return true;
1142 default:
1143 break;
1144 }
1145 return false;
1146}
1147
Eric Laurented726cc2021-07-01 14:26:41 +02001148/* static */
1149bool AudioPolicyService::isAppOpSource(audio_source_t source)
1150{
1151 switch (source) {
1152 case AUDIO_SOURCE_FM_TUNER:
1153 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent637bd202021-09-22 11:17:11 +02001154 case AUDIO_SOURCE_REMOTE_SUBMIX:
Eric Laurented726cc2021-07-01 14:26:41 +02001155 return false;
1156 default:
1157 break;
1158 }
1159 return true;
1160}
1161
Eric Laurent8c7ef892021-06-10 13:32:16 +02001162void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001163{
1164 AutoCallerClear acc;
1165
1166 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001167 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001168 }
1169 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1170 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001171 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001172 if (client->silenced != silenced) {
1173 if (client->active) {
1174 if (silenced) {
1175 finishRecording(client->attributionSource, client->attributes.source);
1176 } else {
1177 std::stringstream msg;
1178 msg << "Audio recording un-silenced on session " << client->session;
1179 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1180 client->attributes.source)) {
1181 silenced = true;
1182 }
1183 }
1184 }
1185 af->setRecordSilenced(client->portId, silenced);
1186 client->silenced = silenced;
1187 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001188 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001189}
1190
Glenn Kasten0f11b512014-01-31 16:18:54 -08001191status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001192{
Glenn Kasten44deb052012-02-05 18:09:08 -08001193 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001194 dumpPermissionDenial(fd);
1195 } else {
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001196 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001197 if (!locked) {
1198 String8 result(kDeadlockedString);
1199 write(fd, result.string(), result.size());
1200 }
1201
1202 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001203
1204 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
1205 write(fd, actPtr.string(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001206 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001207 mAudioCommandThread->dump(fd);
1208 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001209
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001210 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
1211 write(fd, octPtr.string(), octPtr.size());
1212 if (mOutputCommandThread != 0) {
1213 mOutputCommandThread->dump(fd);
1214 }
1215
Eric Laurentdce54a12014-03-10 12:19:46 -07001216 if (mAudioPolicyManager) {
1217 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001218 } else {
1219 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
1220 write(fd, apmPtr.string(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001221 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001222
Kevin Rocard8be94972019-02-22 13:26:25 -08001223 mPackageManager.dump(fd);
1224
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001225 dumpReleaseLock(mLock, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001226
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001227 if (mSpatializer != nullptr) {
1228 std::string dumpString = mSpatializer->toString(1 /* level */);
1229 write(fd, dumpString.c_str(), dumpString.size());
1230 } else {
1231 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1232 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1233 }
1234
Andy Hungc747c532022-03-07 21:41:14 -08001235 {
1236 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1237 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1238 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1239 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001240 }
1241 return NO_ERROR;
1242}
1243
1244status_t AudioPolicyService::dumpPermissionDenial(int fd)
1245{
1246 const size_t SIZE = 256;
1247 char buffer[SIZE];
1248 String8 result;
1249 snprintf(buffer, SIZE, "Permission Denial: "
1250 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1251 IPCThreadState::self()->getCallingPid(),
1252 IPCThreadState::self()->getCallingUid());
1253 result.append(buffer);
1254 write(fd, result.string(), result.size());
1255 return NO_ERROR;
1256}
1257
1258status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001259 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001260 // make sure transactions reserved to AudioFlinger do not come from other processes
1261 switch (code) {
1262 case TRANSACTION_startOutput:
1263 case TRANSACTION_stopOutput:
1264 case TRANSACTION_releaseOutput:
1265 case TRANSACTION_getInputForAttr:
1266 case TRANSACTION_startInput:
1267 case TRANSACTION_stopInput:
1268 case TRANSACTION_releaseInput:
1269 case TRANSACTION_getOutputForEffect:
1270 case TRANSACTION_registerEffect:
1271 case TRANSACTION_unregisterEffect:
1272 case TRANSACTION_setEffectEnabled:
1273 case TRANSACTION_getStrategyForStream:
1274 case TRANSACTION_getOutputForAttr:
1275 case TRANSACTION_moveEffectsToIo:
1276 ALOGW("%s: transaction %d received from PID %d",
1277 __func__, code, IPCThreadState::self()->getCallingPid());
1278 return INVALID_OPERATION;
1279 default:
1280 break;
1281 }
1282
1283 // make sure the following transactions come from system components
1284 switch (code) {
1285 case TRANSACTION_setDeviceConnectionState:
1286 case TRANSACTION_handleDeviceConfigChange:
1287 case TRANSACTION_setPhoneState:
1288//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1289// case TRANSACTION_setForceUse:
1290 case TRANSACTION_initStreamVolume:
1291 case TRANSACTION_setStreamVolumeIndex:
1292 case TRANSACTION_setVolumeIndexForAttributes:
1293 case TRANSACTION_getStreamVolumeIndex:
1294 case TRANSACTION_getVolumeIndexForAttributes:
1295 case TRANSACTION_getMinVolumeIndexForAttributes:
1296 case TRANSACTION_getMaxVolumeIndexForAttributes:
1297 case TRANSACTION_isStreamActive:
1298 case TRANSACTION_isStreamActiveRemotely:
1299 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001300 case TRANSACTION_registerPolicyMixes:
1301 case TRANSACTION_setMasterMono:
1302 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001303 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001304 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001305 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001306 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001307 case TRANSACTION_setA11yServicesUids:
1308 case TRANSACTION_setUidDeviceAffinities:
1309 case TRANSACTION_removeUidDeviceAffinities:
1310 case TRANSACTION_setUserIdDeviceAffinities:
1311 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001312 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001313 case TRANSACTION_listAudioVolumeGroups:
1314 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1315 case TRANSACTION_acquireSoundTriggerSession:
1316 case TRANSACTION_releaseSoundTriggerSession:
1317 case TRANSACTION_setRttEnabled:
1318 case TRANSACTION_isCallScreenModeSupported:
1319 case TRANSACTION_setDevicesRoleForStrategy:
1320 case TRANSACTION_setSupportedSystemUsages:
1321 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001322 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001323 case TRANSACTION_getDevicesForRoleAndStrategy:
1324 case TRANSACTION_getDevicesForAttributes:
1325 case TRANSACTION_setAllowedCapturePolicy:
1326 case TRANSACTION_onNewAudioModulesAvailable:
1327 case TRANSACTION_setCurrentImeUid:
1328 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1329 case TRANSACTION_setDevicesRoleForCapturePreset:
1330 case TRANSACTION_addDevicesRoleForCapturePreset:
1331 case TRANSACTION_removeDevicesRoleForCapturePreset:
1332 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001333 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001334 case TRANSACTION_getSpatializer:
1335 case TRANSACTION_setPreferredMixerAttributes:
1336 case TRANSACTION_clearPreferredMixerAttributes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001337 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1338 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1339 __func__, code, IPCThreadState::self()->getCallingPid(),
1340 IPCThreadState::self()->getCallingUid());
1341 return INVALID_OPERATION;
1342 }
1343 } break;
1344 default:
1345 break;
1346 }
1347
Andy Hungc747c532022-03-07 21:41:14 -08001348 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1349 mediautils::TimeCheck check(
1350 std::string("IAudioPolicyService::").append(methodName),
1351 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1352 if (timeout) {
1353 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1354 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1355 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1356 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1357 .record();
1358 } else {
1359 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1360 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001361 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1362 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1363 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001364
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001365 switch (code) {
1366 case SHELL_COMMAND_TRANSACTION: {
1367 int in = data.readFileDescriptor();
1368 int out = data.readFileDescriptor();
1369 int err = data.readFileDescriptor();
1370 int argc = data.readInt32();
1371 Vector<String16> args;
1372 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1373 args.add(data.readString16());
1374 }
1375 sp<IBinder> unusedCallback;
1376 sp<IResultReceiver> resultReceiver;
1377 status_t status;
1378 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1379 return status;
1380 }
1381 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1382 return status;
1383 }
1384 status = shellCommand(in, out, err, args);
1385 if (resultReceiver != nullptr) {
1386 resultReceiver->send(status);
1387 }
1388 return NO_ERROR;
1389 }
1390 }
1391
Mathias Agopian65ab4712010-07-14 17:59:35 -07001392 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1393}
1394
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001395// ------------------- Shell command implementation -------------------
1396
1397// NOTE: This is a remote API - make sure all args are validated
1398status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1399 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1400 return PERMISSION_DENIED;
1401 }
1402 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1403 return BAD_VALUE;
1404 }
jovanakbe066e12019-09-02 11:54:39 -07001405 if (args.size() >= 3 && args[0] == String16("set-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001406 return handleSetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001407 } else if (args.size() >= 2 && args[0] == String16("reset-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001408 return handleResetUidState(args, err);
jovanakbe066e12019-09-02 11:54:39 -07001409 } else if (args.size() >= 2 && args[0] == String16("get-uid-state")) {
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001410 return handleGetUidState(args, out, err);
Eric Laurent269acb42021-04-23 16:53:22 +02001411 } else if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
1412 purgePermissionCache();
1413 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001414 } else if (args.size() == 1 && args[0] == String16("help")) {
1415 printHelp(out);
1416 return NO_ERROR;
1417 }
1418 printHelp(err);
1419 return BAD_VALUE;
1420}
1421
jovanakbe066e12019-09-02 11:54:39 -07001422static status_t getUidForPackage(String16 packageName, int userId, /*inout*/uid_t& uid, int err) {
1423 if (userId < 0) {
1424 ALOGE("Invalid user: %d", userId);
1425 dprintf(err, "Invalid user: %d\n", userId);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001426 return BAD_VALUE;
1427 }
jovanakbe066e12019-09-02 11:54:39 -07001428
1429 PermissionController pc;
1430 uid = pc.getPackageUid(packageName, 0);
1431 if (uid <= 0) {
1432 ALOGE("Unknown package: '%s'", String8(packageName).string());
1433 dprintf(err, "Unknown package: '%s'\n", String8(packageName).string());
1434 return BAD_VALUE;
1435 }
1436
1437 uid = multiuser_get_uid(userId, uid);
1438 return NO_ERROR;
1439}
1440
1441status_t AudioPolicyService::handleSetUidState(Vector<String16>& args, int err) {
1442 // Valid arg.size() is 3 or 5, args.size() is 5 with --user option.
1443 if (!(args.size() == 3 || args.size() == 5)) {
1444 printHelp(err);
1445 return BAD_VALUE;
1446 }
1447
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001448 bool active = false;
1449 if (args[2] == String16("active")) {
1450 active = true;
1451 } else if ((args[2] != String16("idle"))) {
1452 ALOGE("Expected active or idle but got: '%s'", String8(args[2]).string());
1453 return BAD_VALUE;
1454 }
jovanakbe066e12019-09-02 11:54:39 -07001455
1456 int userId = 0;
1457 if (args.size() >= 5 && args[3] == String16("--user")) {
1458 userId = atoi(String8(args[4]));
1459 }
1460
1461 uid_t uid;
1462 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1463 return BAD_VALUE;
1464 }
1465
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001466 sp<UidPolicy> uidPolicy;
1467 {
1468 Mutex::Autolock _l(mLock);
1469 uidPolicy = mUidPolicy;
1470 }
1471 if (uidPolicy) {
1472 uidPolicy->addOverrideUid(uid, active);
1473 return NO_ERROR;
1474 }
1475 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001476}
1477
1478status_t AudioPolicyService::handleResetUidState(Vector<String16>& args, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001479 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1480 if (!(args.size() == 2 || args.size() == 4)) {
1481 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001482 return BAD_VALUE;
1483 }
jovanakbe066e12019-09-02 11:54:39 -07001484
1485 int userId = 0;
1486 if (args.size() >= 4 && args[2] == String16("--user")) {
1487 userId = atoi(String8(args[3]));
1488 }
1489
1490 uid_t uid;
1491 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1492 return BAD_VALUE;
1493 }
1494
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001495 sp<UidPolicy> uidPolicy;
1496 {
1497 Mutex::Autolock _l(mLock);
1498 uidPolicy = mUidPolicy;
1499 }
1500 if (uidPolicy) {
1501 uidPolicy->removeOverrideUid(uid);
1502 return NO_ERROR;
1503 }
1504 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001505}
1506
1507status_t AudioPolicyService::handleGetUidState(Vector<String16>& args, int out, int err) {
jovanakbe066e12019-09-02 11:54:39 -07001508 // Valid arg.size() is 2 or 4, args.size() is 4 with --user option.
1509 if (!(args.size() == 2 || args.size() == 4)) {
1510 printHelp(err);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001511 return BAD_VALUE;
1512 }
jovanakbe066e12019-09-02 11:54:39 -07001513
1514 int userId = 0;
1515 if (args.size() >= 4 && args[2] == String16("--user")) {
1516 userId = atoi(String8(args[3]));
1517 }
1518
1519 uid_t uid;
1520 if (getUidForPackage(args[1], userId, uid, err) == BAD_VALUE) {
1521 return BAD_VALUE;
1522 }
1523
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001524 sp<UidPolicy> uidPolicy;
1525 {
1526 Mutex::Autolock _l(mLock);
1527 uidPolicy = mUidPolicy;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001528 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +00001529 if (uidPolicy) {
1530 return dprintf(out, uidPolicy->isUidActive(uid) ? "active\n" : "idle\n");
1531 }
1532 return NO_INIT;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001533}
1534
1535status_t AudioPolicyService::printHelp(int out) {
1536 return dprintf(out, "Audio policy service commands:\n"
jovanakbe066e12019-09-02 11:54:39 -07001537 " get-uid-state <PACKAGE> [--user USER_ID] gets the uid state\n"
1538 " set-uid-state <PACKAGE> <active|idle> [--user USER_ID] overrides the uid state\n"
1539 " reset-uid-state <PACKAGE> [--user USER_ID] clears the uid state override\n"
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001540 " help print this message\n");
1541}
1542
Eric Laurent0d13fea2022-11-04 17:12:08 +01001543status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1544 const audio_config_base_t& config,
1545 const audio_output_flags_t flags) {
1546 return mUsecaseValidator->registerStream(output, config, flags);
1547}
1548
1549status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1550 return mUsecaseValidator->unregisterStream(output);
1551}
1552
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001553// ----------- AudioPolicyService::UidPolicy implementation ----------
1554
1555void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001556 status_t res = mAm.linkToDeath(this);
1557 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001558 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001559 | ActivityManager::UID_OBSERVER_ACTIVE
1560 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001561 ActivityManager::PROCESS_STATE_UNKNOWN,
1562 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001563 if (!res) {
1564 Mutex::Autolock _l(mLock);
1565 mObserverRegistered = true;
1566 } else {
1567 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001568
Steven Moreland2f348142019-07-02 15:59:07 -07001569 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001570 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001571}
1572
1573void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001574 mAm.unlinkToDeath(this);
1575 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001576 Mutex::Autolock _l(mLock);
1577 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001578}
1579
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001580void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
1581 Mutex::Autolock _l(mLock);
1582 mCachedUids.clear();
1583 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001584}
1585
Eric Laurente8c8b432018-10-17 10:08:02 -07001586void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001587 bool needToReregister = false;
1588 {
1589 Mutex::Autolock _l(mLock);
1590 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001591 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001592 if (needToReregister) {
1593 // Looks like ActivityManager has died previously, attempt to re-register.
1594 registerSelf();
1595 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001596}
1597
1598bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1599 if (isServiceUid(uid)) return true;
1600 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001601 {
1602 Mutex::Autolock _l(mLock);
1603 auto overrideIter = mOverrideUids.find(uid);
1604 if (overrideIter != mOverrideUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001605 return overrideIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001606 }
1607 // In an absense of the ActivityManager, assume everything to be active.
1608 if (!mObserverRegistered) return true;
1609 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001610 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001611 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001612 }
1613 }
1614 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001615 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001616 {
1617 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001618 mCachedUids.insert(std::pair<uid_t,
1619 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1620 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001621 }
1622 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001623}
1624
Eric Laurente8c8b432018-10-17 10:08:02 -07001625int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1626 if (isServiceUid(uid)) {
1627 return ActivityManager::PROCESS_STATE_TOP;
1628 }
1629 checkRegistered();
1630 {
1631 Mutex::Autolock _l(mLock);
1632 auto overrideIter = mOverrideUids.find(uid);
1633 if (overrideIter != mOverrideUids.end()) {
1634 if (overrideIter->second.first) {
1635 if (overrideIter->second.second != ActivityManager::PROCESS_STATE_UNKNOWN) {
1636 return overrideIter->second.second;
1637 } else {
1638 auto cacheIter = mCachedUids.find(uid);
1639 if (cacheIter != mCachedUids.end()) {
1640 return cacheIter->second.second;
1641 }
1642 }
1643 }
1644 return ActivityManager::PROCESS_STATE_UNKNOWN;
1645 }
1646 // In an absense of the ActivityManager, assume everything to be active.
1647 if (!mObserverRegistered) {
1648 return ActivityManager::PROCESS_STATE_TOP;
1649 }
1650 auto cacheIter = mCachedUids.find(uid);
1651 if (cacheIter != mCachedUids.end()) {
1652 if (cacheIter->second.first) {
1653 return cacheIter->second.second;
1654 } else {
1655 return ActivityManager::PROCESS_STATE_UNKNOWN;
1656 }
1657 }
1658 }
1659 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001660 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001661 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1662 if (active) {
1663 state = am.getUidProcessState(uid, String16("audioserver"));
1664 }
1665 {
1666 Mutex::Autolock _l(mLock);
1667 mCachedUids.insert(std::pair<uid_t,
1668 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1669 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001670
Eric Laurente8c8b432018-10-17 10:08:02 -07001671 return state;
1672}
1673
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001674void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001675 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001676}
1677
1678void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001679 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001680}
1681
1682void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001683 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001684}
1685
Eric Laurente8c8b432018-10-17 10:08:02 -07001686void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1687 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001688 int64_t procStateSeq __unused,
1689 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001690 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1691 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001692 }
1693}
1694
Austin Borger65577682022-02-17 00:25:43 +00001695void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused) {
1696}
1697
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001698void AudioPolicyService::UidPolicy::updateOverrideUid(uid_t uid, bool active, bool insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001699 updateUid(&mOverrideUids, uid, active, ActivityManager::PROCESS_STATE_UNKNOWN, insert);
1700}
1701
1702void AudioPolicyService::UidPolicy::notifyService() {
1703 sp<AudioPolicyService> service = mService.promote();
1704 if (service != nullptr) {
1705 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001706 }
1707}
1708
Eric Laurente8c8b432018-10-17 10:08:02 -07001709void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1710 std::pair<bool, int>> *uids,
1711 uid_t uid,
1712 bool active,
1713 int state,
1714 bool insert) {
1715 if (isServiceUid(uid)) {
1716 return;
1717 }
1718 bool wasActive = isUidActive(uid);
1719 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001720 {
1721 Mutex::Autolock _l(mLock);
Eric Laurente8c8b432018-10-17 10:08:02 -07001722 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001723 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001724 if (wasActive != isUidActive(uid) || state != previousState) {
1725 notifyService();
1726 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001727}
1728
Eric Laurente8c8b432018-10-17 10:08:02 -07001729void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1730 std::pair<bool, int>> *uids,
1731 uid_t uid,
1732 bool active,
1733 int state,
1734 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001735 auto it = uids->find(uid);
1736 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001737 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001738 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1739 it->second.first = active;
1740 }
1741 if (it->second.first) {
1742 it->second.second = state;
1743 } else {
1744 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1745 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001746 } else {
1747 uids->erase(it);
1748 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001749 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1750 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1751 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001752 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001753}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001754
Eric Laurent4eb58f12018-12-07 16:41:02 -08001755bool AudioPolicyService::UidPolicy::isA11yOnTop() {
lihong80e1f56e2022-08-25 11:15:33 +08001756 Mutex::Autolock _l(mLock);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001757 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001758 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001759 continue;
1760 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001761 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1762 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001763 return true;
1764 }
1765 }
1766 return false;
1767}
1768
Eric Laurentb78763e2018-10-17 10:08:02 -07001769bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1770{
1771 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1772 return it != mA11yUids.end();
1773}
1774
Oscar Azucena829d90d2022-01-28 17:17:56 -08001775void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1776 mAssistantUids.clear();
1777 mAssistantUids = uids;
1778}
1779
1780bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1781{
1782 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1783 return it != mAssistantUids.end();
1784}
1785
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001786void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1787 mActiveAssistantUids = activeUids;
1788}
1789
1790bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1791{
1792 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1793 mActiveAssistantUids.end(), uid);
1794 return it != mActiveAssistantUids.end();
1795}
1796
Oscar Azucena829d90d2022-01-28 17:17:56 -08001797void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1798 const size_t SIZE = 256;
1799 char buffer[SIZE];
1800 String8 result;
1801 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1802 snprintf(buffer, SIZE, "\t%s: \n", title);
1803 result.append(buffer);
1804 int counter = 0;
1805 if (uids.empty()) {
1806 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1807 result.append(buffer);
1808 return;
1809 }
1810 for (const auto &uid : uids) {
1811 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1812 result.append(buffer);
1813 }
1814 };
1815
1816 snprintf(buffer, SIZE, "UID Policy:\n");
1817 result.append(buffer);
1818 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1819 result.append(buffer);
1820
1821 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001822 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001823
1824 appendUidsToResult("Accessibility UIDs", mA11yUids);
1825
1826 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1827 result.append(buffer);
1828
1829 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1830 result.append(buffer);
1831
1832 write(fd, result.string(), result.size());
1833}
1834
Michael Groovercfd28302018-12-11 19:16:46 -08001835// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1836void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1837 SensorPrivacyManager spm;
1838 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
Eric Laurent35cd7932022-11-17 11:47:19 +01001839 (void)spm.addToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001840 spm.addSensorPrivacyListener(this);
1841}
1842
1843void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1844 SensorPrivacyManager spm;
1845 spm.removeSensorPrivacyListener(this);
Eric Laurent35cd7932022-11-17 11:47:19 +01001846 spm.removeToggleSensorPrivacyListener(this);
Michael Groovercfd28302018-12-11 19:16:46 -08001847}
1848
1849bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1850 return mSensorPrivacyEnabled;
1851}
1852
Evan Seversond8dc6832022-01-27 10:47:03 -08001853binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1854 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001855 mSensorPrivacyEnabled = enabled;
1856 sp<AudioPolicyService> service = mService.promote();
1857 if (service != nullptr) {
1858 service->updateUidStates();
1859 }
1860 return binder::Status::ok();
1861}
1862
Eric Laurented726cc2021-07-01 14:26:41 +02001863// ----------- AudioPolicyService::OpRecordAudioMonitor implementation ----------
1864
1865// static
1866sp<AudioPolicyService::OpRecordAudioMonitor>
1867AudioPolicyService::OpRecordAudioMonitor::createIfNeeded(
1868 const AttributionSourceState& attributionSource, const audio_attributes_t& attr,
1869 wp<AudioCommandThread> commandThread)
1870{
Eric Laurent987ce102021-07-05 12:11:51 +02001871 if (isAudioServerOrRootUid(attributionSource.uid)) {
1872 ALOGV("not silencing record for audio or root source %s",
Eric Laurented726cc2021-07-01 14:26:41 +02001873 attributionSource.toString().c_str());
1874 return nullptr;
1875 }
1876
1877 if (!AudioPolicyService::isAppOpSource(attr.source)) {
1878 ALOGD("not monitoring app op for uid %d and source %d",
1879 attributionSource.uid, attr.source);
1880 return nullptr;
1881 }
1882
1883 if (!attributionSource.packageName.has_value()
1884 || attributionSource.packageName.value().size() == 0) {
1885 return nullptr;
1886 }
1887 return new OpRecordAudioMonitor(attributionSource, getOpForSource(attr.source), commandThread);
1888}
1889
1890AudioPolicyService::OpRecordAudioMonitor::OpRecordAudioMonitor(
1891 const AttributionSourceState& attributionSource, int32_t appOp,
1892 wp<AudioCommandThread> commandThread) :
1893 mHasOp(true), mAttributionSource(attributionSource), mAppOp(appOp),
1894 mCommandThread(commandThread)
1895{
1896}
1897
1898AudioPolicyService::OpRecordAudioMonitor::~OpRecordAudioMonitor()
1899{
1900 if (mOpCallback != 0) {
1901 mAppOpsManager.stopWatchingMode(mOpCallback);
1902 }
1903 mOpCallback.clear();
1904}
1905
1906void AudioPolicyService::OpRecordAudioMonitor::onFirstRef()
1907{
1908 checkOp();
1909 mOpCallback = new RecordAudioOpCallback(this);
1910 ALOGV("start watching op %d for %s", mAppOp, mAttributionSource.toString().c_str());
1911 // TODO: We need to always watch AppOpsManager::OP_RECORD_AUDIO too
1912 // since it controls the mic permission for legacy apps.
1913 mAppOpsManager.startWatchingMode(mAppOp, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1914 mAttributionSource.packageName.value_or(""))),
1915 mOpCallback);
1916}
1917
1918bool AudioPolicyService::OpRecordAudioMonitor::hasOp() const {
1919 return mHasOp.load();
1920}
1921
1922// Called by RecordAudioOpCallback when the app op corresponding to this OpRecordAudioMonitor
1923// is updated in AppOp callback and in onFirstRef()
1924// Note this method is never called (and never to be) for audio server / root track
1925// due to the UID in createIfNeeded(). As a result for those record track, it's:
1926// - not called from constructor,
1927// - not called from RecordAudioOpCallback because the callback is not installed in this case
1928void AudioPolicyService::OpRecordAudioMonitor::checkOp(bool updateUidStates)
1929{
1930 // TODO: We need to always check AppOpsManager::OP_RECORD_AUDIO too
1931 // since it controls the mic permission for legacy apps.
1932 const int32_t mode = mAppOpsManager.checkOp(mAppOp,
1933 mAttributionSource.uid, VALUE_OR_FATAL(aidl2legacy_string_view_String16(
1934 mAttributionSource.packageName.value_or(""))));
1935 const bool hasIt = (mode == AppOpsManager::MODE_ALLOWED);
1936 // verbose logging only log when appOp changed
1937 ALOGI_IF(hasIt != mHasOp.load(),
1938 "App op %d missing, %ssilencing record %s",
1939 mAppOp, hasIt ? "un" : "", mAttributionSource.toString().c_str());
1940 mHasOp.store(hasIt);
1941
1942 if (updateUidStates) {
1943 sp<AudioCommandThread> commandThread = mCommandThread.promote();
1944 if (commandThread != nullptr) {
1945 commandThread->updateUidStatesCommand();
1946 }
1947 }
1948}
1949
1950AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::RecordAudioOpCallback(
1951 const wp<OpRecordAudioMonitor>& monitor) : mMonitor(monitor)
1952{ }
1953
1954void AudioPolicyService::OpRecordAudioMonitor::RecordAudioOpCallback::opChanged(int32_t op,
1955 const String16& packageName __unused) {
1956 sp<OpRecordAudioMonitor> monitor = mMonitor.promote();
1957 if (monitor != NULL) {
1958 if (op != monitor->getOp()) {
1959 return;
1960 }
1961 monitor->checkOp(true);
1962 }
1963}
1964
1965
Mathias Agopian65ab4712010-07-14 17:59:35 -07001966// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1967
Eric Laurentbfb1b832013-01-07 09:53:42 -08001968AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1969 const wp<AudioPolicyService>& service)
1970 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001971{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001972}
1973
1974
1975AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1976{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001977 if (!mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001978 release_wake_lock(mName.string());
1979 }
1980 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001981}
1982
1983void AudioPolicyService::AudioCommandThread::onFirstRef()
1984{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001985 run(mName.string(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001986}
1987
1988bool AudioPolicyService::AudioCommandThread::threadLoop()
1989{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001990 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001991
1992 mLock.lock();
1993 while (!exitPending())
1994 {
Eric Laurent59a89232014-06-08 14:14:17 -07001995 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001996 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001997 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001998 nsecs_t curTime = systemTime();
1999 // commands are sorted by increasing time stamp: execute them from index 0 and up
2000 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002001 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002002 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002003 if (mAudioCommands.isEmpty()) {
2004 ++numTimesBecameEmpty;
2005 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002006 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002007
2008 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002009 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002010 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002011 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07002012 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002013 mLock.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07002014 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
2015 data->mVolume,
2016 data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002017 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002018 }break;
2019 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002020 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002021 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
2022 data->mKeyValuePairs.string(), data->mIO);
Andy Hungfe726a62018-09-27 15:17:25 -07002023 mLock.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002024 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hungfe726a62018-09-27 15:17:25 -07002025 mLock.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002026 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002027 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002028 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01002029 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07002030 data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002031 mLock.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002032 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hungfe726a62018-09-27 15:17:25 -07002033 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002034 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002035 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002036 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002037 ALOGV("AudioCommandThread() processing stop output portId %d",
2038 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002039 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002040 if (svc == 0) {
2041 break;
2042 }
2043 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002044 svc->doStopOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002045 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002046 }break;
2047 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002048 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002049 ALOGV("AudioCommandThread() processing release output portId %d",
2050 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07002051 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002052 if (svc == 0) {
2053 break;
2054 }
2055 mLock.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002056 svc->doReleaseOutput(data->mPortId);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002057 mLock.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002058 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07002059 case CREATE_AUDIO_PATCH: {
2060 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
2061 ALOGV("AudioCommandThread() processing create audio patch");
2062 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2063 if (af == 0) {
2064 command->mStatus = PERMISSION_DENIED;
2065 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002066 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002067 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002068 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002069 }
2070 } break;
2071 case RELEASE_AUDIO_PATCH: {
2072 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
2073 ALOGV("AudioCommandThread() processing release audio patch");
2074 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2075 if (af == 0) {
2076 command->mStatus = PERMISSION_DENIED;
2077 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002078 mLock.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07002079 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hungfe726a62018-09-27 15:17:25 -07002080 mLock.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07002081 }
2082 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07002083 case UPDATE_AUDIOPORT_LIST: {
2084 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07002085 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002086 if (svc == 0) {
2087 break;
2088 }
2089 mLock.unlock();
2090 svc->doOnAudioPortListUpdate();
2091 mLock.lock();
2092 }break;
2093 case UPDATE_AUDIOPATCH_LIST: {
2094 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07002095 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07002096 if (svc == 0) {
2097 break;
2098 }
2099 mLock.unlock();
2100 svc->doOnAudioPatchListUpdate();
2101 mLock.lock();
2102 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01002103 case CHANGED_AUDIOVOLUMEGROUP: {
2104 AudioVolumeGroupData *data =
2105 static_cast<AudioVolumeGroupData *>(command->mParam.get());
2106 ALOGV("AudioCommandThread() processing update audio volume group");
2107 svc = mService.promote();
2108 if (svc == 0) {
2109 break;
2110 }
2111 mLock.unlock();
2112 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
2113 mLock.lock();
2114 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07002115 case SET_AUDIOPORT_CONFIG: {
2116 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
2117 ALOGV("AudioCommandThread() processing set port config");
2118 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2119 if (af == 0) {
2120 command->mStatus = PERMISSION_DENIED;
2121 } else {
Andy Hungfe726a62018-09-27 15:17:25 -07002122 mLock.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07002123 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hungfe726a62018-09-27 15:17:25 -07002124 mLock.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07002125 }
2126 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07002127 case DYN_POLICY_MIX_STATE_UPDATE: {
2128 DynPolicyMixStateUpdateData *data =
2129 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07002130 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
2131 data->mRegId.string(), data->mState);
2132 svc = mService.promote();
2133 if (svc == 0) {
2134 break;
2135 }
2136 mLock.unlock();
2137 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
2138 mLock.lock();
2139 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002140 case RECORDING_CONFIGURATION_UPDATE: {
2141 RecordingConfigurationUpdateData *data =
2142 (RecordingConfigurationUpdateData *)command->mParam.get();
2143 ALOGV("AudioCommandThread() processing recording configuration update");
2144 svc = mService.promote();
2145 if (svc == 0) {
2146 break;
2147 }
2148 mLock.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002149 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08002150 &data->mClientConfig, data->mClientEffects,
2151 &data->mDeviceConfig, data->mEffects,
2152 data->mPatchHandle, data->mSource);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002153 mLock.lock();
2154 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002155 case SET_EFFECT_SUSPENDED: {
2156 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
2157 ALOGV("AudioCommandThread() processing set effect suspended");
2158 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
2159 if (af != 0) {
2160 mLock.unlock();
2161 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
2162 mLock.lock();
2163 }
2164 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002165 case AUDIO_MODULES_UPDATE: {
2166 ALOGV("AudioCommandThread() processing audio modules update");
2167 svc = mService.promote();
2168 if (svc == 0) {
2169 break;
2170 }
2171 mLock.unlock();
2172 svc->doOnNewAudioModulesAvailable();
2173 mLock.lock();
2174 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002175 case ROUTING_UPDATED: {
2176 ALOGV("AudioCommandThread() processing routing update");
2177 svc = mService.promote();
2178 if (svc == 0) {
2179 break;
2180 }
2181 mLock.unlock();
2182 svc->doOnRoutingUpdated();
2183 mLock.lock();
2184 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002185
Eric Laurented726cc2021-07-01 14:26:41 +02002186 case UPDATE_UID_STATES: {
2187 ALOGV("AudioCommandThread() processing updateUID states");
2188 svc = mService.promote();
2189 if (svc == 0) {
2190 break;
2191 }
2192 mLock.unlock();
2193 svc->updateUidStates();
2194 mLock.lock();
2195 } break;
2196
Eric Laurent15903592022-02-24 20:44:36 +01002197 case CHECK_SPATIALIZER_OUTPUT: {
2198 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02002199 svc = mService.promote();
2200 if (svc == 0) {
2201 break;
2202 }
2203 mLock.unlock();
2204 svc->doOnCheckSpatializer();
2205 mLock.lock();
2206 } break;
2207
Eric Laurent15903592022-02-24 20:44:36 +01002208 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2209 ALOGV("AudioCommandThread() processing update spatializer tracks");
2210 svc = mService.promote();
2211 if (svc == 0) {
2212 break;
2213 }
2214 mLock.unlock();
2215 svc->doOnUpdateActiveSpatializerTracks();
2216 mLock.lock();
2217 } break;
2218
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002219 case VOL_RANGE_INIT_REQUEST: {
2220 ALOGV("AudioCommandThread() processing volume range init request");
2221 svc = mService.promote();
2222 if (svc == 0) {
2223 break;
2224 }
2225 mLock.unlock();
2226 svc->doOnVolumeRangeInitRequest();
2227 mLock.lock();
2228 } break;
2229
Mathias Agopian65ab4712010-07-14 17:59:35 -07002230 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002231 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002232 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002233 {
2234 Mutex::Autolock _l(command->mLock);
2235 if (command->mWaitStatus) {
2236 command->mWaitStatus = false;
2237 command->mCond.signal();
2238 }
2239 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002240 waitTime = -1;
Zach Janga754b4f2015-10-27 01:29:34 +00002241 // release mLock before releasing strong reference on the service as
2242 // AudioPolicyService destructor calls AudioCommandThread::exit() which
2243 // acquires mLock.
2244 mLock.unlock();
2245 svc.clear();
2246 mLock.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002247 } else {
2248 waitTime = mAudioCommands[0]->mTime - curTime;
2249 break;
2250 }
2251 }
Zach Janga754b4f2015-10-27 01:29:34 +00002252
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002253 // release delayed commands wake lock as many times as we made the queue is
2254 // empty during popping.
2255 while (numTimesBecameEmpty--) {
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002256 release_wake_lock(mName.string());
Zach Janga754b4f2015-10-27 01:29:34 +00002257 }
2258
2259 // At this stage we have either an empty command queue or the first command in the queue
2260 // has a finite delay. So unless we are exiting it is safe to wait.
2261 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002262 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002263 if (waitTime == -1) {
2264 mWaitWorkCV.wait(mLock);
2265 } else {
2266 mWaitWorkCV.waitRelative(mLock, waitTime);
2267 }
Eric Laurent59a89232014-06-08 14:14:17 -07002268 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002269 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002270 // release delayed commands wake lock before quitting
2271 if (!mAudioCommands.isEmpty()) {
2272 release_wake_lock(mName.string());
2273 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002274 mLock.unlock();
2275 return false;
2276}
2277
2278status_t AudioPolicyService::AudioCommandThread::dump(int fd)
2279{
2280 const size_t SIZE = 256;
2281 char buffer[SIZE];
2282 String8 result;
2283
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002284 const bool locked = dumpTryLock(mLock);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002285 if (!locked) {
2286 String8 result2(kCmdDeadlockedString);
2287 write(fd, result2.string(), result2.size());
2288 }
2289
2290 snprintf(buffer, SIZE, "- Commands:\n");
2291 result = String8(buffer);
2292 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002293 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002294 mAudioCommands[i]->dump(buffer, SIZE);
2295 result.append(buffer);
2296 }
2297 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002298 if (mLastCommand != 0) {
2299 mLastCommand->dump(buffer, SIZE);
2300 result.append(buffer);
2301 } else {
2302 result.append(" none\n");
2303 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002304
2305 write(fd, result.string(), result.size());
2306
Mikhail Naganov12b716c2020-04-30 22:37:43 +00002307 dumpReleaseLock(mLock, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002308
2309 return NO_ERROR;
2310}
2311
Glenn Kastenfff6d712012-01-12 16:38:12 -08002312status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002313 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002314 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002315 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002316{
Eric Laurent0ede8922014-05-09 18:04:42 -07002317 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002318 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002319 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002320 data->mStream = stream;
2321 data->mVolume = volume;
2322 data->mIO = output;
2323 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002324 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002325 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002326 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002327 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002328}
2329
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002330status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002331 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002332 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002333{
Eric Laurent0ede8922014-05-09 18:04:42 -07002334 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002335 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002336 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002337 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002338 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002339 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002340 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002341 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002342 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002343 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002344}
2345
2346status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2347{
Eric Laurent0ede8922014-05-09 18:04:42 -07002348 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002349 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002350 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002351 data->mVolume = volume;
2352 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002353 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002354 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002355 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002356}
2357
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002358void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2359 audio_session_t sessionId,
2360 bool suspended)
2361{
2362 sp<AudioCommand> command = new AudioCommand();
2363 command->mCommand = SET_EFFECT_SUSPENDED;
2364 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2365 data->mEffectId = effectId;
2366 data->mSessionId = sessionId;
2367 data->mSuspended = suspended;
2368 command->mParam = data;
2369 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2370 effectId, sessionId, suspended);
2371 sendCommand(command);
2372}
2373
2374
Eric Laurentd7fe0862018-07-14 16:48:01 -07002375void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002376{
Eric Laurent0ede8922014-05-09 18:04:42 -07002377 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002378 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002379 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002380 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002381 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002382 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002383 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002384}
2385
Eric Laurentd7fe0862018-07-14 16:48:01 -07002386void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002387{
Eric Laurent0ede8922014-05-09 18:04:42 -07002388 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002389 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002390 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002391 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002392 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002393 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002394 sendCommand(command);
2395}
2396
Eric Laurent951f4552014-05-20 10:48:17 -07002397status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2398 const struct audio_patch *patch,
2399 audio_patch_handle_t *handle,
2400 int delayMs)
2401{
2402 status_t status = NO_ERROR;
2403
2404 sp<AudioCommand> command = new AudioCommand();
2405 command->mCommand = CREATE_AUDIO_PATCH;
2406 CreateAudioPatchData *data = new CreateAudioPatchData();
2407 data->mPatch = *patch;
2408 data->mHandle = *handle;
2409 command->mParam = data;
2410 command->mWaitStatus = true;
2411 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2412 status = sendCommand(command, delayMs);
2413 if (status == NO_ERROR) {
2414 *handle = data->mHandle;
2415 }
2416 return status;
2417}
2418
2419status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2420 int delayMs)
2421{
2422 sp<AudioCommand> command = new AudioCommand();
2423 command->mCommand = RELEASE_AUDIO_PATCH;
2424 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2425 data->mHandle = handle;
2426 command->mParam = data;
2427 command->mWaitStatus = true;
2428 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2429 return sendCommand(command, delayMs);
2430}
2431
Eric Laurentb52c1522014-05-20 11:27:36 -07002432void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2433{
2434 sp<AudioCommand> command = new AudioCommand();
2435 command->mCommand = UPDATE_AUDIOPORT_LIST;
2436 ALOGV("AudioCommandThread() adding update audio port list");
2437 sendCommand(command);
2438}
2439
Eric Laurented726cc2021-07-01 14:26:41 +02002440void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2441{
2442 sp<AudioCommand> command = new AudioCommand();
2443 command->mCommand = UPDATE_UID_STATES;
2444 ALOGV("AudioCommandThread() adding update UID states");
2445 sendCommand(command);
2446}
2447
Eric Laurentb52c1522014-05-20 11:27:36 -07002448void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2449{
2450 sp<AudioCommand>command = new AudioCommand();
2451 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2452 ALOGV("AudioCommandThread() adding update audio patch list");
2453 sendCommand(command);
2454}
2455
François Gaffiecfe17322018-11-07 13:41:29 +01002456void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2457 int flags)
2458{
2459 sp<AudioCommand>command = new AudioCommand();
2460 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2461 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2462 data->mGroup = group;
2463 data->mFlags = flags;
2464 command->mParam = data;
2465 ALOGV("AudioCommandThread() adding audio volume group changed");
2466 sendCommand(command);
2467}
2468
Eric Laurente1715a42014-05-20 11:30:42 -07002469status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2470 const struct audio_port_config *config, int delayMs)
2471{
2472 sp<AudioCommand> command = new AudioCommand();
2473 command->mCommand = SET_AUDIOPORT_CONFIG;
2474 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2475 data->mConfig = *config;
2476 command->mParam = data;
2477 command->mWaitStatus = true;
2478 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2479 return sendCommand(command, delayMs);
2480}
2481
Jean-Michel Trivide801052015-04-14 19:10:14 -07002482void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002483 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002484{
2485 sp<AudioCommand> command = new AudioCommand();
2486 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2487 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2488 data->mRegId = regId;
2489 data->mState = state;
2490 command->mParam = data;
2491 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
2492 regId.string(), state);
2493 sendCommand(command);
2494}
2495
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002496void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002497 int event,
2498 const record_client_info_t *clientInfo,
2499 const audio_config_base_t *clientConfig,
2500 std::vector<effect_descriptor_t> clientEffects,
2501 const audio_config_base_t *deviceConfig,
2502 std::vector<effect_descriptor_t> effects,
2503 audio_patch_handle_t patchHandle,
2504 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002505{
2506 sp<AudioCommand>command = new AudioCommand();
2507 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2508 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2509 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002510 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002511 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002512 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002513 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002514 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002515 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002516 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002517 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002518 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2519 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002520 sendCommand(command);
2521}
2522
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002523void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2524{
2525 sp<AudioCommand> command = new AudioCommand();
2526 command->mCommand = AUDIO_MODULES_UPDATE;
2527 sendCommand(command);
2528}
2529
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002530void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2531{
2532 sp<AudioCommand>command = new AudioCommand();
2533 command->mCommand = ROUTING_UPDATED;
2534 ALOGV("AudioCommandThread() adding routing update");
2535 sendCommand(command);
2536}
2537
Eric Laurent81dd0f52021-07-05 11:54:40 +02002538void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2539{
2540 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002541 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002542 ALOGV("AudioCommandThread() adding check spatializer");
2543 sendCommand(command);
2544}
2545
Eric Laurent15903592022-02-24 20:44:36 +01002546void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2547{
2548 sp<AudioCommand>command = new AudioCommand();
2549 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2550 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2551 sendCommand(command);
2552}
2553
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002554void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2555{
2556 sp<AudioCommand>command = new AudioCommand();
2557 command->mCommand = VOL_RANGE_INIT_REQUEST;
2558 ALOGV("AudioCommandThread() adding volume range init request");
2559 sendCommand(command);
2560}
2561
Eric Laurent0ede8922014-05-09 18:04:42 -07002562status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2563{
2564 {
2565 Mutex::Autolock _l(mLock);
2566 insertCommand_l(command, delayMs);
2567 mWaitWorkCV.signal();
2568 }
2569 Mutex::Autolock _l(command->mLock);
2570 while (command->mWaitStatus) {
2571 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
2572 if (command->mCond.waitRelative(command->mLock, timeOutNs) != NO_ERROR) {
2573 command->mStatus = TIMED_OUT;
2574 command->mWaitStatus = false;
2575 }
2576 }
2577 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002578}
2579
Mathias Agopian65ab4712010-07-14 17:59:35 -07002580// insertCommand_l() must be called with mLock held
Eric Laurent0ede8922014-05-09 18:04:42 -07002581void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002582{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002583 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002584 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002585 command->mTime = systemTime() + milliseconds(delayMs);
2586
2587 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002588 if (mAudioCommands.isEmpty()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002589 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());
2590 }
2591
2592 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002593 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002594 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002595 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2596 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002597
2598 // create audio patch or release audio patch commands are equivalent
2599 // with regard to filtering
2600 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2601 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2602 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2603 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2604 continue;
2605 }
2606 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002607
2608 switch (command->mCommand) {
2609 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002610 ParametersData *data = (ParametersData *)command->mParam.get();
2611 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002612 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002613 ALOGV("Comparing parameter command %s to new command %s",
Eric Laurentde070132010-07-13 04:45:46 -07002614 data2->mKeyValuePairs.string(), data->mKeyValuePairs.string());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002615 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2616 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2617 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002618 String8 key;
2619 String8 value;
2620 param.getAt(j, key, value);
2621 for (size_t k = 0; k < param2.size(); k++) {
2622 String8 key2;
2623 String8 value2;
2624 param2.getAt(k, key2, value2);
2625 if (key2 == key) {
2626 param2.remove(key2);
2627 ALOGV("Filtering out parameter %s", key2.string());
2628 break;
2629 }
2630 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002631 }
2632 // if all keys have been filtered out, remove the command.
2633 // otherwise, update the key value pairs
2634 if (param2.size() == 0) {
2635 removedCommands.add(command2);
2636 } else {
2637 data2->mKeyValuePairs = param2.toString();
2638 }
Eric Laurent21e54562013-09-23 12:08:05 -07002639 command->mTime = command2->mTime;
2640 // force delayMs to non 0 so that code below does not request to wait for
2641 // command status as the command is now delayed
2642 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002643 } break;
2644
2645 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002646 VolumeData *data = (VolumeData *)command->mParam.get();
2647 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002648 if (data->mIO != data2->mIO) break;
2649 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002650 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002651 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002652 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002653 command->mTime = command2->mTime;
2654 // force delayMs to non 0 so that code below does not request to wait for
2655 // command status as the command is now delayed
2656 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002657 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002658
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002659 case SET_VOICE_VOLUME: {
2660 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2661 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2662 ALOGV("Filtering out voice volume command value %f replaced by %f",
2663 data2->mVolume, data->mVolume);
2664 removedCommands.add(command2);
2665 command->mTime = command2->mTime;
2666 // force delayMs to non 0 so that code below does not request to wait for
2667 // command status as the command is now delayed
2668 delayMs = 1;
2669 } break;
2670
Eric Laurente45b48a2014-09-04 16:40:57 -07002671 case CREATE_AUDIO_PATCH:
2672 case RELEASE_AUDIO_PATCH: {
2673 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002674 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002675 if (command->mCommand == CREATE_AUDIO_PATCH) {
2676 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002677 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002678 } else {
2679 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002680 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002681 }
2682 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002683 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002684 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2685 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002686 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002687 } else {
2688 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002689 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002690 }
2691 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002692 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2693 same output. */
2694 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2695 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2696 bool isOutputDiff = false;
2697 if (patch.num_sources == patch2.num_sources) {
2698 for (unsigned count = 0; count < patch.num_sources; count++) {
2699 if (patch.sources[count].id != patch2.sources[count].id) {
2700 isOutputDiff = true;
2701 break;
2702 }
2703 }
2704 if (isOutputDiff)
2705 break;
2706 }
2707 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002708 ALOGV("Filtering out %s audio patch command for handle %d",
2709 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2710 removedCommands.add(command2);
2711 command->mTime = command2->mTime;
2712 // force delayMs to non 0 so that code below does not request to wait for
2713 // command status as the command is now delayed
2714 delayMs = 1;
2715 } break;
2716
Jean-Michel Trivide801052015-04-14 19:10:14 -07002717 case DYN_POLICY_MIX_STATE_UPDATE: {
2718
2719 } break;
2720
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002721 case RECORDING_CONFIGURATION_UPDATE: {
2722
2723 } break;
2724
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002725 case ROUTING_UPDATED: {
2726
2727 } break;
2728
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002729 case VOL_RANGE_INIT_REQUEST: {
2730 // command may come from different requests, do not filter
2731 } break;
2732
Mathias Agopian65ab4712010-07-14 17:59:35 -07002733 default:
2734 break;
2735 }
2736 }
2737
2738 // remove filtered commands
2739 for (size_t j = 0; j < removedCommands.size(); j++) {
2740 // removed commands always have time stamps greater than current command
2741 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002742 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002743 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002744 mAudioCommands.removeAt(k);
2745 break;
2746 }
2747 }
2748 }
2749 removedCommands.clear();
2750
Eric Laurentaa79bef2015-01-15 14:33:51 -08002751 // Disable wait for status if delay is not 0.
2752 // Except for create audio patch command because the returned patch handle
2753 // is needed by audio policy manager
2754 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002755 command->mWaitStatus = false;
2756 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002757
Mathias Agopian65ab4712010-07-14 17:59:35 -07002758 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002759 ALOGV("inserting command: %d at index %zd, num commands %zu",
2760 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002761 mAudioCommands.insertAt(command, i + 1);
2762}
2763
2764void AudioPolicyService::AudioCommandThread::exit()
2765{
Steve Block3856b092011-10-20 11:56:00 +01002766 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002767 {
2768 AutoMutex _l(mLock);
2769 requestExit();
2770 mWaitWorkCV.signal();
2771 }
Zach Janga754b4f2015-10-27 01:29:34 +00002772 // Note that we can call it from the thread loop if all other references have been released
2773 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002774 requestExitAndWait();
2775}
2776
2777void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2778{
2779 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2780 mCommand,
2781 (int)ns2s(mTime),
2782 (int)ns2ms(mTime)%1000,
2783 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002784 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002785}
2786
Dima Zavinfce7a472011-04-19 22:30:36 -07002787/******* helpers for the service_ops callbacks defined below *********/
2788void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2789 const char *keyValuePairs,
2790 int delayMs)
2791{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002792 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002793 delayMs);
2794}
2795
2796int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2797 float volume,
2798 audio_io_handle_t output,
2799 int delayMs)
2800{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002801 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002802 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002803}
2804
Dima Zavinfce7a472011-04-19 22:30:36 -07002805int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2806{
2807 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2808}
2809
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002810void AudioPolicyService::setEffectSuspended(int effectId,
2811 audio_session_t sessionId,
2812 bool suspended)
2813{
2814 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2815}
2816
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002817Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002818{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002819 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002820 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002821}
2822
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002823
Dima Zavinfce7a472011-04-19 22:30:36 -07002824extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002825audio_module_handle_t aps_load_hw_module(void *service __unused,
2826 const char *name);
2827audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002828 audio_devices_t *pDevices,
2829 uint32_t *pSamplingRate,
2830 audio_format_t *pFormat,
2831 audio_channel_mask_t *pChannelMask,
2832 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002833 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002834
Eric Laurent2d388ec2014-03-07 13:25:54 -08002835audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002836 audio_module_handle_t module,
2837 audio_devices_t *pDevices,
2838 uint32_t *pSamplingRate,
2839 audio_format_t *pFormat,
2840 audio_channel_mask_t *pChannelMask,
2841 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002842 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002843 const audio_offload_info_t *offloadInfo);
2844audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002845 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002846 audio_io_handle_t output2);
2847int aps_close_output(void *service __unused, audio_io_handle_t output);
2848int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2849int aps_restore_output(void *service __unused, audio_io_handle_t output);
2850audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002851 audio_devices_t *pDevices,
2852 uint32_t *pSamplingRate,
2853 audio_format_t *pFormat,
2854 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002855 audio_in_acoustics_t acoustics __unused);
2856audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002857 audio_module_handle_t module,
2858 audio_devices_t *pDevices,
2859 uint32_t *pSamplingRate,
2860 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002861 audio_channel_mask_t *pChannelMask);
2862int aps_close_input(void *service __unused, audio_io_handle_t input);
2863int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002864int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002865 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002866 audio_io_handle_t dst_output);
2867char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2868 const char *keys);
2869void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2870 const char *kv_pairs, int delay_ms);
2871int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002872 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002873 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002874int aps_set_voice_volume(void *service, float volume, int delay_ms);
2875};
Dima Zavinfce7a472011-04-19 22:30:36 -07002876
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002877} // namespace android