blob: 2edb596dd8cfae0a99514fc482ece8cdc43af3fc [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#include <stdint.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070022#include <sys/time.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053023#include <dlfcn.h>
Mikhail Naganov959e2d02019-03-28 11:08:19 -070024
25#include <audio_utils/clock.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070026#include <binder/IServiceManager.h>
27#include <utils/Log.h>
28#include <cutils/properties.h>
29#include <binder/IPCThreadState.h>
Svet Ganovf4ddfef2018-01-16 07:37:58 -080030#include <binder/PermissionController.h>
31#include <binder/IResultReceiver.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070032#include <utils/String16.h>
33#include <utils/threads.h>
Atneya Nair5b1ed642023-06-23 14:43:37 -070034#include "AudioRecordClient.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070035#include "AudioPolicyService.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070036#include <hardware_legacy/power.h>
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -080037#include <media/AidlConversion.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070038#include <media/AudioEffect.h>
Chih-Hung Hsiehc84d9d22014-11-14 13:33:34 -080039#include <media/AudioParameter.h>
Andy Hungc747c532022-03-07 21:41:14 -080040#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070041#include <mediautils/ServiceUtilities.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080042#include <mediautils/TimeCheck.h>
Michael Groovercfd28302018-12-11 19:16:46 -080043#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070044
Dima Zavin64760242011-05-11 14:15:23 -070045#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070046#include <system/audio_policy.h>
Mikhail Naganov68e3f642023-04-28 13:06:32 -070047#include <AudioPolicyConfig.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053048#include <AudioPolicyManager.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070049
Mathias Agopian65ab4712010-07-14 17:59:35 -070050namespace android {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080051using binder::Status;
Shunkai Yao49bc61f2023-10-10 19:31:10 +000052using media::audio::common::Spatialization;
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) \
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200121BINDER_METHOD_ENTRY(updatePolicyMixes) \
Andy Hungc747c532022-03-07 21:41:14 -0800122BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
123BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
124BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
125BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
126BINDER_METHOD_ENTRY(startAudioSource) \
127BINDER_METHOD_ENTRY(stopAudioSource) \
128BINDER_METHOD_ENTRY(setMasterMono) \
129BINDER_METHOD_ENTRY(getMasterMono) \
130BINDER_METHOD_ENTRY(getStreamVolumeDB) \
131BINDER_METHOD_ENTRY(getSurroundFormats) \
132BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
133BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
134BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
135BINDER_METHOD_ENTRY(setAssistantServicesUids) \
136BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
137BINDER_METHOD_ENTRY(setA11yServicesUids) \
138BINDER_METHOD_ENTRY(setCurrentImeUid) \
139BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
140BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800141BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800142BINDER_METHOD_ENTRY(listAudioProductStrategies) \
143BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
144BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
145BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
146BINDER_METHOD_ENTRY(setRttEnabled) \
147BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
148BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
149BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000150BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800151BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
152BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
157BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
158BINDER_METHOD_ENTRY(getSpatializer) \
159BINDER_METHOD_ENTRY(canBeSpatialized) \
160BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000161BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
162BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
163BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
164BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
165BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100166BINDER_METHOD_ENTRY(getRegisteredPolicyMixes) \
167 \
Andy Hungc747c532022-03-07 21:41:14 -0800168// singleton for Binder Method Statistics for IAudioPolicyService
169static auto& getIAudioPolicyServiceStatistics() {
170 using Code = int;
171
172#pragma push_macro("BINDER_METHOD_ENTRY")
173#undef BINDER_METHOD_ENTRY
174#define BINDER_METHOD_ENTRY(ENTRY) \
175 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
176
177 static mediautils::MethodStatistics<Code> methodStatistics{
178 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
179 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
180 };
181#pragma pop_macro("BINDER_METHOD_ENTRY")
182
183 return methodStatistics;
184}
185
Mathias Agopian65ab4712010-07-14 17:59:35 -0700186// ----------------------------------------------------------------------------
187
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530188static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
189{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700190 AudioPolicyManager *apm = nullptr;
191 media::AudioPolicyConfig apmConfig;
192 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
193 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
194 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
195 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
196 "Only default engine is currently supported with the AIDL HAL");
197 apm = new AudioPolicyManager(config,
198 loadApmEngineLibraryAndCreateEngine(
199 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
200 clientInterface);
201 } else {
202 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
203 apm = new AudioPolicyManager(config,
204 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
205 clientInterface);
206 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530207 status_t status = apm->initialize();
208 if (status != NO_ERROR) {
209 delete apm;
210 apm = nullptr;
211 }
212 return apm;
213}
214
215static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
216{
217 delete interface;
218}
219// ----------------------------------------------------------------------------
220
Mathias Agopian65ab4712010-07-14 17:59:35 -0700221AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700222 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700223 mAudioPolicyManager(NULL),
224 mAudioPolicyClient(NULL),
225 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530226 mCaptureStateNotifier(false),
227 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100228 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
229 mUsecaseValidator(media::createUsecaseValidator()) {
Andy Hung225aef62022-12-06 16:33:20 -0800230 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530231}
232
233void AudioPolicyService::loadAudioPolicyManager()
234{
235 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
236 if (mLibraryHandle != nullptr) {
237 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
238 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
239 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
240 const char *lastError = dlerror();
241 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
242 __func__, lastError != nullptr ? lastError : "no error");
243
244 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
245 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
246 lastError = dlerror();
247 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
248 __func__, lastError != nullptr ? lastError : "no error");
249 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
250 unloadAudioPolicyManager();
251 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
252 }
253 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700254}
255
256void AudioPolicyService::onFirstRef()
257{
Andy Hungd47aca22022-03-15 11:50:51 -0700258 // Log an AudioPolicy "constructor" mediametrics event on first ref.
259 // This records the time it takes to load the audio modules and devices.
260 mediametrics::Defer defer([beginNs = systemTime()] {
261 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
262 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
263 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
264 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700265 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800266 audio_utils::lock_guard _l(mMutex);
Eric Laurent93575202011-01-18 18:39:02 -0800267
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700268 // start audio commands thread
269 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
270 // start output activity command thread
271 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700272
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700273 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530274
275 loadAudioPolicyManager();
276 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700277 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200278
bryant_liuba2b4392014-06-11 16:49:30 +0800279 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000280 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
Andy Hungd3595ed2023-12-19 15:34:46 -0800281 auto audioPolicyEffects = sp<AudioPolicyEffects>::make(effectsFactoryHal);
282 auto uidPolicy = sp<UidPolicy>::make(this);
283 auto sensorPrivacyPolicy = sp<SensorPrivacyPolicy>::make(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700284 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800285 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700286 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000287 mUidPolicy = uidPolicy;
288 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000290 uidPolicy->registerSelf();
291 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200292
Eric Laurent81dd0f52021-07-05 11:54:40 +0200293 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200294 if (mAudioPolicyManager != nullptr) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800295 audio_utils::lock_guard _l(mMutex);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200296 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
297 AudioDeviceTypeAddrVector devices;
298 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
299 if (hasSpatializer) {
Andy Hung1040da52023-12-06 20:59:06 -0800300 // Unlock as Spatializer::create() will use the callback and acquire the
301 // AudioPolicyService_Mutex.
Andy Hung79eacdb2023-11-30 19:34:24 -0800302 mMutex.unlock();
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000303 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Andy Hung79eacdb2023-11-30 19:34:24 -0800304 mMutex.lock();
Eric Laurent52b0bd52021-09-27 15:25:40 +0200305 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700306 if (mSpatializer == nullptr) {
307 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
308 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
309 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
310 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200311 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200312 AudioSystem::audioPolicyReady();
Andy Hungb08b3752024-01-09 19:05:23 -0800313}
314
315void AudioPolicyService::onAudioSystemReady() {
316 sp<AudioPolicyEffects> audioPolicyEffects;
317 {
318 audio_utils::lock_guard _l(mMutex);
319
320 audioPolicyEffects = mAudioPolicyEffects;
321 }
322 audioPolicyEffects->initDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700323}
324
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530325void AudioPolicyService::unloadAudioPolicyManager()
326{
327 ALOGV("%s ", __func__);
328 if (mLibraryHandle != nullptr) {
329 dlclose(mLibraryHandle);
330 }
331 mLibraryHandle = nullptr;
332 mCreateAudioPolicyManager = nullptr;
333 mDestroyAudioPolicyManager = nullptr;
334}
335
Mathias Agopian65ab4712010-07-14 17:59:35 -0700336AudioPolicyService::~AudioPolicyService()
337{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700338 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700339 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700340
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530341 mDestroyAudioPolicyManager(mAudioPolicyManager);
342 unloadAudioPolicyManager();
343
Eric Laurentdce54a12014-03-10 12:19:46 -0700344 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700345
346 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800347 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800348
349 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800350 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000351
352 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800353 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700354}
355
356// A notification client is always registered by AudioSystem when the client process
357// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800358Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700359{
Eric Laurent12590252015-08-21 18:40:20 -0700360 if (client == 0) {
361 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800362 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700363 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800364 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700365
366 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800367 pid_t pid = IPCThreadState::self()->getCallingPid();
368 int64_t token = ((int64_t)uid<<32) | pid;
369
370 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700371 sp<NotificationClient> notificationClient = new NotificationClient(this,
372 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800373 uid,
374 pid);
375 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700376
luochaojiang908c7d72018-06-21 14:58:04 +0800377 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700378
Marco Nelissenf8880202014-11-14 07:58:25 -0800379 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700380 binder->linkToDeath(notificationClient);
381 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800382 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700383}
384
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800385Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700386{
Andy Hung79eacdb2023-11-30 19:34:24 -0800387 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurente8726fe2015-06-26 09:39:24 -0700388
389 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800390 pid_t pid = IPCThreadState::self()->getCallingPid();
391 int64_t token = ((int64_t)uid<<32) | pid;
392
393 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800394 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700395 }
luochaojiang908c7d72018-06-21 14:58:04 +0800396 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800397 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700398}
399
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800400Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100401{
Andy Hung79eacdb2023-11-30 19:34:24 -0800402 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100403
404 uid_t uid = IPCThreadState::self()->getCallingUid();
405 pid_t pid = IPCThreadState::self()->getCallingPid();
406 int64_t token = ((int64_t)uid<<32) | pid;
407
408 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800409 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100410 }
411 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800412 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100413}
414
Eric Laurentb52c1522014-05-20 11:27:36 -0700415// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800416void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700417{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000418 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800419 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800420 audio_utils::lock_guard _l(mNotificationClientsMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800421 int64_t token = ((int64_t)uid<<32) | pid;
422 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800423 for (size_t i = 0; i < mNotificationClients.size(); i++) {
424 if (mNotificationClients.valueAt(i)->uid() == uid) {
425 hasSameUid = true;
426 break;
427 }
428 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000429 }
430 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800431 audio_utils::lock_guard _l(mMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800432 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700433 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700434 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700435 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800436 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700437}
438
439void AudioPolicyService::onAudioPortListUpdate()
440{
441 mOutputCommandThread->updateAudioPortListCommand();
442}
443
444void AudioPolicyService::doOnAudioPortListUpdate()
445{
Andy Hung79eacdb2023-11-30 19:34:24 -0800446 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700447 for (size_t i = 0; i < mNotificationClients.size(); i++) {
448 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
449 }
450}
451
452void AudioPolicyService::onAudioPatchListUpdate()
453{
454 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700455}
456
Eric Laurentb52c1522014-05-20 11:27:36 -0700457void AudioPolicyService::doOnAudioPatchListUpdate()
458{
Andy Hung79eacdb2023-11-30 19:34:24 -0800459 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700460 for (size_t i = 0; i < mNotificationClients.size(); i++) {
461 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
462 }
463}
464
François Gaffiecfe17322018-11-07 13:41:29 +0100465void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
466{
467 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
468}
469
470void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
471{
Andy Hung79eacdb2023-11-30 19:34:24 -0800472 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100473 for (size_t i = 0; i < mNotificationClients.size(); i++) {
474 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
475 }
476}
477
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700478void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700479{
480 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000481 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700482 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
483}
484
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700485void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700486{
Andy Hung79eacdb2023-11-30 19:34:24 -0800487 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700488 for (size_t i = 0; i < mNotificationClients.size(); i++) {
489 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
490 }
491}
492
Eric Laurenta9f86652018-11-28 17:23:11 -0800493void AudioPolicyService::onRecordingConfigurationUpdate(
494 int event,
495 const record_client_info_t *clientInfo,
496 const audio_config_base_t *clientConfig,
497 std::vector<effect_descriptor_t> clientEffects,
498 const audio_config_base_t *deviceConfig,
499 std::vector<effect_descriptor_t> effects,
500 audio_patch_handle_t patchHandle,
501 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800502{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800503 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800504 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800505}
506
Eric Laurenta9f86652018-11-28 17:23:11 -0800507void AudioPolicyService::doOnRecordingConfigurationUpdate(
508 int event,
509 const record_client_info_t *clientInfo,
510 const audio_config_base_t *clientConfig,
511 std::vector<effect_descriptor_t> clientEffects,
512 const audio_config_base_t *deviceConfig,
513 std::vector<effect_descriptor_t> effects,
514 audio_patch_handle_t patchHandle,
515 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800516{
Andy Hung79eacdb2023-11-30 19:34:24 -0800517 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800518 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800519 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800520 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800521 }
522}
523
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700524void AudioPolicyService::onRoutingUpdated()
525{
526 mOutputCommandThread->routingChangedCommand();
527}
528
529void AudioPolicyService::doOnRoutingUpdated()
530{
Andy Hung79eacdb2023-11-30 19:34:24 -0800531 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700532 for (size_t i = 0; i < mNotificationClients.size(); i++) {
533 mNotificationClients.valueAt(i)->onRoutingUpdated();
534 }
535}
536
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000537void AudioPolicyService::onVolumeRangeInitRequest()
538{
539 mOutputCommandThread->volRangeInitReqCommand();
540}
541
542void AudioPolicyService::doOnVolumeRangeInitRequest()
543{
Andy Hung79eacdb2023-11-30 19:34:24 -0800544 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000545 for (size_t i = 0; i < mNotificationClients.size(); i++) {
546 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
547 }
548}
549
Eric Laurent81dd0f52021-07-05 11:54:40 +0200550void AudioPolicyService::onCheckSpatializer()
551{
Andy Hung79eacdb2023-11-30 19:34:24 -0800552 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200553 onCheckSpatializer_l();
554}
555
556void AudioPolicyService::onCheckSpatializer_l()
557{
558 if (mSpatializer != nullptr) {
559 mOutputCommandThread->checkSpatializerCommand();
560 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200561}
562
563void AudioPolicyService::doOnCheckSpatializer()
564{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200565 ALOGV("%s mSpatializer %p level %d",
566 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200567
Eric Laurent39095982021-08-24 18:29:27 +0200568 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200569 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000570 if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200571 audio_io_handle_t currentOutput = mSpatializer->getOutput();
572 audio_io_handle_t newOutput;
573 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
574 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200575
Andy Hung79eacdb2023-11-30 19:34:24 -0800576 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200577 status_t status =
578 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100579 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
580 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200581 if (status == NO_ERROR && currentOutput == newOutput) {
582 return;
583 }
Eric Laurent15903592022-02-24 20:44:36 +0100584 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Andy Hung79eacdb2023-11-30 19:34:24 -0800585 mMutex.unlock();
Eric Laurent39095982021-08-24 18:29:27 +0200586 // It is OK to call detachOutput() is none is already attached.
587 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200588 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
589 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200590 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800591 mMutex.lock();
Eric Laurent39095982021-08-24 18:29:27 +0200592 if (status != NO_ERROR) {
593 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
594 }
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000595 } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
596 mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200597 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200598
Eric Laurent39095982021-08-24 18:29:27 +0200599 if (output != AUDIO_IO_HANDLE_NONE) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800600 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200601 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200602 }
603 }
604 }
605}
606
Eric Laurent11094172022-04-05 18:27:42 +0200607size_t AudioPolicyService::countActiveClientsOnOutput_l(
608 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100609 size_t count = 0;
610 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
611 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200612 if (client->io == output && client->active
613 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100614 count++;
615 }
616 }
617 return count;
618}
619
620void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
621 if (mSpatializer == nullptr) {
622 return;
623 }
624 mOutputCommandThread->updateActiveSpatializerTracksCommand();
625}
626
627void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
628{
Eric Laurent21270b62022-07-04 15:11:29 +0200629 if (mSpatializer == nullptr) {
630 return;
631 }
632 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200633 size_t activeClients;
634 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800635 audio_utils::lock_guard _l(mMutex);
Eric Laurent21270b62022-07-04 15:11:29 +0200636 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100637 }
Eric Laurent21270b62022-07-04 15:11:29 +0200638 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100639}
640
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800641status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
642 audio_patch_handle_t *handle,
643 int delayMs)
644{
645 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
646}
647
648status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
649 int delayMs)
650{
651 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
652}
653
Eric Laurente1715a42014-05-20 11:30:42 -0700654status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
655 int delayMs)
656{
657 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
658}
659
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800660AudioPolicyService::NotificationClient::NotificationClient(
661 const sp<AudioPolicyService>& service,
662 const sp<media::IAudioPolicyServiceClient>& client,
663 uid_t uid,
664 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800665 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100666 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700667{
668}
669
670AudioPolicyService::NotificationClient::~NotificationClient()
671{
672}
673
674void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
675{
676 sp<NotificationClient> keep(this);
677 sp<AudioPolicyService> service = mService.promote();
678 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800679 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700680 }
681}
682
683void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
684{
Eric Laurente8726fe2015-06-26 09:39:24 -0700685 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700686 mAudioPolicyServiceClient->onAudioPortListUpdate();
687 }
688}
689
690void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
691{
Eric Laurente8726fe2015-06-26 09:39:24 -0700692 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700693 mAudioPolicyServiceClient->onAudioPatchListUpdate();
694 }
695}
Eric Laurent57dae992011-07-24 13:36:09 -0700696
Pattydd807582021-11-04 21:01:03 +0800697void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100698 int flags)
699{
700 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
701 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
702 }
703}
704
705
Jean-Michel Trivide801052015-04-14 19:10:14 -0700706void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700707 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700708{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700709 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800710 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
711 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800712 }
713}
714
715void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800716 int event,
717 const record_client_info_t *clientInfo,
718 const audio_config_base_t *clientConfig,
719 std::vector<effect_descriptor_t> clientEffects,
720 const audio_config_base_t *deviceConfig,
721 std::vector<effect_descriptor_t> effects,
722 audio_patch_handle_t patchHandle,
723 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800724{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700725 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800726 status_t status = [&]() -> status_t {
727 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
728 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
729 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700730 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700731 legacy2aidl_audio_config_base_t_AudioConfigBase(
732 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800733 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
734 convertContainer<std::vector<media::EffectDescriptor>>(
735 clientEffects,
736 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700737 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700738 legacy2aidl_audio_config_base_t_AudioConfigBase(
739 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800740 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
741 convertContainer<std::vector<media::EffectDescriptor>>(
742 effects,
743 legacy2aidl_effect_descriptor_t_EffectDescriptor));
744 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
745 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700746 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
747 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800748 return aidl_utils::statusTFromBinderStatus(
749 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
750 clientInfoAidl,
751 clientConfigAidl,
752 clientEffectsAidl,
753 deviceConfigAidl,
754 effectsAidl,
755 patchHandleAidl,
756 sourceAidl));
757 }();
758 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700759 }
760}
761
Eric Laurente8726fe2015-06-26 09:39:24 -0700762void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
763{
764 mAudioPortCallbacksEnabled = enabled;
765}
766
François Gaffiecfe17322018-11-07 13:41:29 +0100767void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
768{
769 mAudioVolumeGroupCallbacksEnabled = enabled;
770}
Eric Laurente8726fe2015-06-26 09:39:24 -0700771
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700772void AudioPolicyService::NotificationClient::onRoutingUpdated()
773{
774 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
775 mAudioPolicyServiceClient->onRoutingUpdated();
776 }
777}
778
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000779void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
780{
781 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
782 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
783 }
784}
785
Mathias Agopian65ab4712010-07-14 17:59:35 -0700786void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700787 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700788 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700789}
790
Andy Hung79eacdb2023-11-30 19:34:24 -0800791static void dumpReleaseLock(audio_utils::mutex& mutex, bool locked)
792 RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000793{
794 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700795}
796
797status_t AudioPolicyService::dumpInternals(int fd)
798{
799 const size_t SIZE = 256;
800 char buffer[SIZE];
801 String8 result;
802
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000803 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800804 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000805 std::stringstream msg;
806 size_t i = 0;
807 for (auto usage : mSupportedSystemUsages) {
808 if (i++ != 0) msg << ", ";
809 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
810 msg << strUsage;
811 } else {
812 msg << usage << " (unknown)";
813 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800814 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000815 if (i == 0) {
816 msg << "None";
817 }
818 msg << std::endl;
819 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800820
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000821 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800822
823 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700824 return NO_ERROR;
825}
826
Eric Laurente8c8b432018-10-17 10:08:02 -0700827void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800828{
Andy Hung79eacdb2023-11-30 19:34:24 -0800829 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700830 updateUidStates_l();
831}
832
833void AudioPolicyService::updateUidStates_l()
834{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800835// Go over all active clients and allow capture (does not force silence) in the
836// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800837// The client is in the active assistant list
838// AND is TOP
839// AND an accessibility service is TOP
840// AND source is either VOICE_RECOGNITION OR HOTWORD
841// OR there is no active privacy sensitive capture or call
842// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
843// AND source is VOICE_RECOGNITION OR HOTWORD
844// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800845// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700846// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800847// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800848// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800849// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
850// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800851// OR The client is an accessibility service
852// AND Is on TOP
853// AND the source is VOICE_RECOGNITION or HOTWORD
854// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700855// AND there is no active privacy sensitive capture or call
856// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800857// AND is on TOP
858// AND the source is VOICE_RECOGNITION or HOTWORD
859// OR the client source is virtual (remote submix, call audio TX or RX...)
860// OR the client source is HOTWORD
861// AND is on TOP
862// OR all active clients are using HOTWORD source
863// AND no call is active
864// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
865// OR the client is the current InputMethodService
866// AND a RTT call is active AND the source is VOICE_RECOGNITION
867// OR Any client
868// AND The assistant is not on TOP
869// AND is on TOP or latest started
870// AND there is no active privacy sensitive capture or call
871// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800872
Eric Laurent4e947da2019-10-17 15:24:06 -0700873
Eric Laurent4eb58f12018-12-07 16:41:02 -0800874 sp<AudioRecordClient> topActive;
875 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800876 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700877 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800878 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700879
Eric Laurenta46bedb2018-12-07 18:01:26 -0800880 nsecs_t topStartNs = 0;
881 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800882 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800883 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800884 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800885 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
886 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800887 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800888 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700889 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800890 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
891 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700892 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700893 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700894 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800895
Michael Groovercfd28302018-12-11 19:16:46 -0800896 // if Sensor Privacy is enabled then all recordings should be silenced.
897 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
898 silenceAllRecordings_l();
899 return;
900 }
901
Eric Laurente8c8b432018-10-17 10:08:02 -0700902 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
903 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000904 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
905 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800906 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700907 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800908 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700909
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700910 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700911 // clients which app is in IDLE state are not eligible for top active or
912 // latest active
913 if (appState == APP_STATE_IDLE) {
914 continue;
915 }
916
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700917 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700918 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800919 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700920 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700921 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800922 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800923 bool isPrivacySensitive =
924 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700925
Eric Laurentc21d5692020-02-25 10:24:36 -0800926 if (appState == APP_STATE_TOP) {
927 if (isPrivacySensitive) {
928 if (current->startTimeNs > topSensitiveStartNs) {
929 topSensitiveActive = current;
930 topSensitiveStartNs = current->startTimeNs;
931 }
932 } else {
933 if (current->startTimeNs > topStartNs) {
934 topActive = current;
935 topStartNs = current->startTimeNs;
936 }
937 }
938 if (isAssistant) {
939 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800940 if (isActiveAssistant) {
941 useActiveAssistantList = true;
942 } else if (!useActiveAssistantList) {
943 if (current->startTimeNs > latestAssistantStartNs) {
944 latestActiveAssistant = current;
945 latestAssistantStartNs = current->startTimeNs;
946 }
947 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800948 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800949 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800950 // Clients capturing for HOTWORD are not considered
951 // for latest active to avoid masking regular clients started before
952 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
953 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
954 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700955 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
956 // is marked latest sensitive active even if another app qualifies.
957 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700958 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700959 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700960 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000961 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700962 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700963 latestSensitiveActiveOrComm = current;
964 latestSensitiveStartNs = current->startTimeNs;
965 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800966 }
967 isSensitiveActive = true;
968 } else {
969 if (current->startTimeNs > latestStartNs) {
970 latestActive = current;
971 latestStartNs = current->startTimeNs;
972 }
973 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800974 }
975 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000976 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
977 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700978 onlyHotwordActive = false;
979 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100980 if (currentUid == mPhoneStateOwnerUid &&
981 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700982 isPhoneStateOwnerActive = true;
983 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800984 }
985
Eric Laurent1ff16a72019-03-14 18:35:04 -0700986 // if no active client with UI on Top, consider latest active as top
987 if (topActive == nullptr) {
988 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800989 topStartNs = latestStartNs;
990 }
991 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700992 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800993 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700994 } else if (latestSensitiveActiveOrComm != nullptr) {
995 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
996 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700997 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +0000998 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700999 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -07001000 topSensitiveActive = latestSensitiveActiveOrComm;
1001 topSensitiveStartNs = latestSensitiveStartNs;
1002 }
Eric Laurentc21d5692020-02-25 10:24:36 -08001003 }
1004
1005 // If both privacy sensitive and regular capture are active:
1006 // if the regular capture is privileged
1007 // allow concurrency
1008 // else
1009 // favor the privacy sensitive case
1010 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001011 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001012 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001013 }
1014
1015 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1016 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001017 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001018 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001019 if (!current->active) {
1020 continue;
1021 }
1022
Eric Laurent4eb58f12018-12-07 16:41:02 -08001023 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001024 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001025 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001026 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001027 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001028 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1029 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001030
Andy Hung79eacdb2023-11-30 19:34:24 -08001031 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mMutex) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001032 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001033 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001034 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001035 bool canCaptureCommunication = recordClient->canCaptureOutput
1036 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001037 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001038 return !(isInCall && !canCaptureCall)
1039 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001040 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001041
1042 // By default allow capture if:
1043 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001044 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001045 // AND there is no active privacy sensitive capture or call
1046 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001047 bool allowSensitiveCapture =
1048 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001049 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001050 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001051 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001052 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001053
Eric Laurented726cc2021-07-01 14:26:41 +02001054 if (!current->hasOp()) {
1055 // Never allow capture if app op is denied
1056 allowCapture = false;
1057 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001058 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1059 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001060 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001061 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001062 // Active assistant list is not being used
1063 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001064 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001065 // OR there is no active privacy sensitive capture or call
1066 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1067 // AND is latest TOP assistant AND
1068 // uses VOICE_RECOGNITION OR uses HOTWORD
1069 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001070 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001071 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001072 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001073 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001074 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001075 && canCaptureIfInCallOrCommunication(current)) {
1076 if (isTopOrLatestAssistant
1077 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1078 || source == AUDIO_SOURCE_HOTWORD)) {
1079 allowCapture = true;
1080 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1081 allowCapture = true;
1082 }
1083 }
1084 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1085 // For assistant on active list and on top allow capture if:
1086 // An accessibility service is on TOP
1087 // AND the source is VOICE_RECOGNITION or HOTWORD
1088 // OR there is no active privacy sensitive capture or call
1089 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1090 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1091 if (isA11yOnTop) {
1092 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1093 allowCapture = true;
1094 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001095 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001096 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001097 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1098 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001099 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001100 }
1101 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001102 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001103 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001104 // The assistant is not on TOP
1105 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001106 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001107 // OR
1108 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1109 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001110 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001111 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001112 allowCapture = true;
1113 }
Eric Laurent589171c2019-07-25 18:04:29 -07001114 if (isA11yOnTop) {
1115 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1116 allowCapture = true;
1117 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001118 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001119 } else if (source == AUDIO_SOURCE_HOTWORD) {
1120 // For HOTWORD source allow capture when not on TOP if:
1121 // All active clients are using HOTWORD source
1122 // AND no call is active
1123 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001124 if (onlyHotwordActive
1125 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001126 allowCapture = true;
1127 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001128 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001129 // For current InputMethodService allow capture if:
1130 // A RTT call is active AND the source is VOICE_RECOGNITION
1131 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1132 allowCapture = true;
1133 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001134 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001135 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001136 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001137 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001138 }
1139}
1140
Michael Groovercfd28302018-12-11 19:16:46 -08001141void AudioPolicyService::silenceAllRecordings_l() {
1142 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1143 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001144 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001145 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001146 }
Michael Groovercfd28302018-12-11 19:16:46 -08001147 }
1148}
1149
Eric Laurente8c8b432018-10-17 10:08:02 -07001150/* static */
1151app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001152
1153 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001154 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001155 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1156 // include persistent services
1157 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001158 }
1159 return APP_STATE_FOREGROUND;
1160}
1161
Eric Laurent4eb58f12018-12-07 16:41:02 -08001162/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001163bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001164{
1165 switch (source) {
1166 case AUDIO_SOURCE_VOICE_UPLINK:
1167 case AUDIO_SOURCE_VOICE_DOWNLINK:
1168 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001169 case AUDIO_SOURCE_REMOTE_SUBMIX:
1170 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001171 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001172 return true;
1173 default:
1174 break;
1175 }
1176 return false;
1177}
1178
Eric Laurent8c7ef892021-06-10 13:32:16 +02001179void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001180{
1181 AutoCallerClear acc;
1182
1183 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001184 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001185 }
1186 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1187 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001188 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001189 if (client->silenced != silenced) {
1190 if (client->active) {
1191 if (silenced) {
1192 finishRecording(client->attributionSource, client->attributes.source);
1193 } else {
1194 std::stringstream msg;
1195 msg << "Audio recording un-silenced on session " << client->session;
1196 if (!startRecording(client->attributionSource, String16(msg.str().c_str()),
1197 client->attributes.source)) {
1198 silenced = true;
1199 }
1200 }
1201 }
1202 af->setRecordSilenced(client->portId, silenced);
1203 client->silenced = silenced;
1204 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001205 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001206}
1207
Glenn Kasten0f11b512014-01-31 16:18:54 -08001208status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Andy Hung79eacdb2023-11-30 19:34:24 -08001209NO_THREAD_SAFETY_ANALYSIS // update for trylock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001210{
Glenn Kasten44deb052012-02-05 18:09:08 -08001211 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001212 dumpPermissionDenial(fd);
1213 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001214 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215 if (!locked) {
1216 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001217 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001218 }
1219
1220 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001221
1222 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001223 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001224 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001225 mAudioCommandThread->dump(fd);
1226 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001227
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001228 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001229 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001230 if (mOutputCommandThread != 0) {
1231 mOutputCommandThread->dump(fd);
1232 }
1233
Eric Laurentdce54a12014-03-10 12:19:46 -07001234 if (mAudioPolicyManager) {
1235 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001236 } else {
1237 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001238 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001239 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001240
Kevin Rocard8be94972019-02-22 13:26:25 -08001241 mPackageManager.dump(fd);
1242
Andy Hung79eacdb2023-11-30 19:34:24 -08001243 dumpReleaseLock(mMutex, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001244
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001245 if (mSpatializer != nullptr) {
1246 std::string dumpString = mSpatializer->toString(1 /* level */);
1247 write(fd, dumpString.c_str(), dumpString.size());
1248 } else {
1249 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1250 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1251 }
1252
Andy Hungc747c532022-03-07 21:41:14 -08001253 {
1254 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1255 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1256 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1257 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001258 }
1259 return NO_ERROR;
1260}
1261
1262status_t AudioPolicyService::dumpPermissionDenial(int fd)
1263{
1264 const size_t SIZE = 256;
1265 char buffer[SIZE];
1266 String8 result;
1267 snprintf(buffer, SIZE, "Permission Denial: "
1268 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1269 IPCThreadState::self()->getCallingPid(),
1270 IPCThreadState::self()->getCallingUid());
1271 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001272 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001273 return NO_ERROR;
1274}
1275
1276status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001277 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001278 // make sure transactions reserved to AudioFlinger do not come from other processes
1279 switch (code) {
1280 case TRANSACTION_startOutput:
1281 case TRANSACTION_stopOutput:
1282 case TRANSACTION_releaseOutput:
1283 case TRANSACTION_getInputForAttr:
1284 case TRANSACTION_startInput:
1285 case TRANSACTION_stopInput:
1286 case TRANSACTION_releaseInput:
1287 case TRANSACTION_getOutputForEffect:
1288 case TRANSACTION_registerEffect:
1289 case TRANSACTION_unregisterEffect:
1290 case TRANSACTION_setEffectEnabled:
1291 case TRANSACTION_getStrategyForStream:
1292 case TRANSACTION_getOutputForAttr:
1293 case TRANSACTION_moveEffectsToIo:
1294 ALOGW("%s: transaction %d received from PID %d",
1295 __func__, code, IPCThreadState::self()->getCallingPid());
1296 return INVALID_OPERATION;
1297 default:
1298 break;
1299 }
1300
1301 // make sure the following transactions come from system components
1302 switch (code) {
1303 case TRANSACTION_setDeviceConnectionState:
1304 case TRANSACTION_handleDeviceConfigChange:
1305 case TRANSACTION_setPhoneState:
1306//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1307// case TRANSACTION_setForceUse:
1308 case TRANSACTION_initStreamVolume:
1309 case TRANSACTION_setStreamVolumeIndex:
1310 case TRANSACTION_setVolumeIndexForAttributes:
1311 case TRANSACTION_getStreamVolumeIndex:
1312 case TRANSACTION_getVolumeIndexForAttributes:
1313 case TRANSACTION_getMinVolumeIndexForAttributes:
1314 case TRANSACTION_getMaxVolumeIndexForAttributes:
1315 case TRANSACTION_isStreamActive:
1316 case TRANSACTION_isStreamActiveRemotely:
1317 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001318 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001319 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001320 case TRANSACTION_setMasterMono:
1321 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001322 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001323 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001324 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001325 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001326 case TRANSACTION_setA11yServicesUids:
1327 case TRANSACTION_setUidDeviceAffinities:
1328 case TRANSACTION_removeUidDeviceAffinities:
1329 case TRANSACTION_setUserIdDeviceAffinities:
1330 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001331 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001332 case TRANSACTION_listAudioVolumeGroups:
1333 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1334 case TRANSACTION_acquireSoundTriggerSession:
1335 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001336 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001337 case TRANSACTION_setRttEnabled:
1338 case TRANSACTION_isCallScreenModeSupported:
1339 case TRANSACTION_setDevicesRoleForStrategy:
1340 case TRANSACTION_setSupportedSystemUsages:
1341 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001342 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001343 case TRANSACTION_getDevicesForRoleAndStrategy:
1344 case TRANSACTION_getDevicesForAttributes:
1345 case TRANSACTION_setAllowedCapturePolicy:
1346 case TRANSACTION_onNewAudioModulesAvailable:
1347 case TRANSACTION_setCurrentImeUid:
1348 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1349 case TRANSACTION_setDevicesRoleForCapturePreset:
1350 case TRANSACTION_addDevicesRoleForCapturePreset:
1351 case TRANSACTION_removeDevicesRoleForCapturePreset:
1352 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001353 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001354 case TRANSACTION_getSpatializer:
1355 case TRANSACTION_setPreferredMixerAttributes:
Marvin Raminbdefaf02023-11-01 09:10:32 +01001356 case TRANSACTION_clearPreferredMixerAttributes:
1357 case TRANSACTION_getRegisteredPolicyMixes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001358 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1359 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1360 __func__, code, IPCThreadState::self()->getCallingPid(),
1361 IPCThreadState::self()->getCallingUid());
1362 return INVALID_OPERATION;
1363 }
1364 } break;
1365 default:
1366 break;
1367 }
1368
Andy Hungc747c532022-03-07 21:41:14 -08001369 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1370 mediautils::TimeCheck check(
1371 std::string("IAudioPolicyService::").append(methodName),
1372 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1373 if (timeout) {
1374 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1375 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1376 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1377 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1378 .record();
1379 } else {
1380 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1381 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001382 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1383 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1384 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001385
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001386 switch (code) {
1387 case SHELL_COMMAND_TRANSACTION: {
1388 int in = data.readFileDescriptor();
1389 int out = data.readFileDescriptor();
1390 int err = data.readFileDescriptor();
1391 int argc = data.readInt32();
1392 Vector<String16> args;
1393 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1394 args.add(data.readString16());
1395 }
1396 sp<IBinder> unusedCallback;
1397 sp<IResultReceiver> resultReceiver;
1398 status_t status;
1399 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1400 return status;
1401 }
1402 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1403 return status;
1404 }
1405 status = shellCommand(in, out, err, args);
1406 if (resultReceiver != nullptr) {
1407 resultReceiver->send(status);
1408 }
1409 return NO_ERROR;
1410 }
1411 }
1412
Mathias Agopian65ab4712010-07-14 17:59:35 -07001413 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1414}
1415
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001416// ------------------- Shell command implementation -------------------
1417
1418// NOTE: This is a remote API - make sure all args are validated
1419status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1420 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1421 return PERMISSION_DENIED;
1422 }
1423 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1424 return BAD_VALUE;
1425 }
Atneya Nair56a436a2024-04-03 11:11:58 -07001426 if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
Eric Laurent269acb42021-04-23 16:53:22 +02001427 purgePermissionCache();
1428 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001429 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001430 return BAD_VALUE;
1431}
1432
Eric Laurent0d13fea2022-11-04 17:12:08 +01001433status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1434 const audio_config_base_t& config,
1435 const audio_output_flags_t flags) {
1436 return mUsecaseValidator->registerStream(output, config, flags);
1437}
1438
1439status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1440 return mUsecaseValidator->unregisterStream(output);
1441}
1442
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001443// ----------- AudioPolicyService::UidPolicy implementation ----------
1444
1445void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001446 status_t res = mAm.linkToDeath(this);
1447 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001448 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001449 | ActivityManager::UID_OBSERVER_ACTIVE
1450 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001451 ActivityManager::PROCESS_STATE_UNKNOWN,
1452 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001453 if (!res) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001454 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001455 mObserverRegistered = true;
1456 } else {
1457 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001458
Steven Moreland2f348142019-07-02 15:59:07 -07001459 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001460 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001461}
1462
1463void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001464 mAm.unlinkToDeath(this);
1465 mAm.unregisterUidObserver(this);
Andy Hung79eacdb2023-11-30 19:34:24 -08001466 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001467 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001468}
1469
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001470void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001471 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001472 mCachedUids.clear();
1473 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001474}
1475
Eric Laurente8c8b432018-10-17 10:08:02 -07001476void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001477 bool needToReregister = false;
1478 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001479 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001480 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001481 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001482 if (needToReregister) {
1483 // Looks like ActivityManager has died previously, attempt to re-register.
1484 registerSelf();
1485 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001486}
1487
1488bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1489 if (isServiceUid(uid)) return true;
1490 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001491 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001492 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001493 // In an absense of the ActivityManager, assume everything to be active.
1494 if (!mObserverRegistered) return true;
1495 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001496 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001497 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001498 }
1499 }
1500 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001501 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001502 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001503 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001504 mCachedUids.insert(std::pair<uid_t,
1505 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1506 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001507 }
1508 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001509}
1510
Eric Laurente8c8b432018-10-17 10:08:02 -07001511int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1512 if (isServiceUid(uid)) {
1513 return ActivityManager::PROCESS_STATE_TOP;
1514 }
1515 checkRegistered();
1516 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001517 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001518 // In an absense of the ActivityManager, assume everything to be active.
1519 if (!mObserverRegistered) {
1520 return ActivityManager::PROCESS_STATE_TOP;
1521 }
1522 auto cacheIter = mCachedUids.find(uid);
1523 if (cacheIter != mCachedUids.end()) {
1524 if (cacheIter->second.first) {
1525 return cacheIter->second.second;
1526 } else {
1527 return ActivityManager::PROCESS_STATE_UNKNOWN;
1528 }
1529 }
1530 }
1531 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001532 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001533 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1534 if (active) {
1535 state = am.getUidProcessState(uid, String16("audioserver"));
1536 }
1537 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001538 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001539 mCachedUids.insert(std::pair<uid_t,
1540 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1541 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001542
Eric Laurente8c8b432018-10-17 10:08:02 -07001543 return state;
1544}
1545
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001546void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001547 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001548}
1549
1550void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001551 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001552}
1553
1554void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001555 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001556}
1557
Eric Laurente8c8b432018-10-17 10:08:02 -07001558void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1559 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001560 int64_t procStateSeq __unused,
1561 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001562 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1563 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001564 }
1565}
1566
Austin Borgerdddb7552023-03-30 17:53:01 -07001567void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001568}
1569
Eric Laurente8c8b432018-10-17 10:08:02 -07001570void AudioPolicyService::UidPolicy::notifyService() {
1571 sp<AudioPolicyService> service = mService.promote();
1572 if (service != nullptr) {
1573 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001574 }
1575}
1576
Eric Laurente8c8b432018-10-17 10:08:02 -07001577void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1578 std::pair<bool, int>> *uids,
1579 uid_t uid,
1580 bool active,
1581 int state,
1582 bool insert) {
1583 if (isServiceUid(uid)) {
1584 return;
1585 }
1586 bool wasActive = isUidActive(uid);
1587 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001588 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001589 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001590 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001591 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001592 if (wasActive != isUidActive(uid) || state != previousState) {
1593 notifyService();
1594 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001595}
1596
Eric Laurente8c8b432018-10-17 10:08:02 -07001597void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1598 std::pair<bool, int>> *uids,
1599 uid_t uid,
1600 bool active,
1601 int state,
1602 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001603 auto it = uids->find(uid);
1604 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001605 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001606 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1607 it->second.first = active;
1608 }
1609 if (it->second.first) {
1610 it->second.second = state;
1611 } else {
1612 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1613 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001614 } else {
1615 uids->erase(it);
1616 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001617 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1618 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1619 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001620 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001621}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001622
Eric Laurent4eb58f12018-12-07 16:41:02 -08001623bool AudioPolicyService::UidPolicy::isA11yOnTop() {
Andy Hung79eacdb2023-11-30 19:34:24 -08001624 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001625 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001626 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001627 continue;
1628 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001629 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1630 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001631 return true;
1632 }
1633 }
1634 return false;
1635}
1636
Eric Laurentb78763e2018-10-17 10:08:02 -07001637bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1638{
1639 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1640 return it != mA11yUids.end();
1641}
1642
Oscar Azucena829d90d2022-01-28 17:17:56 -08001643void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1644 mAssistantUids.clear();
1645 mAssistantUids = uids;
1646}
1647
1648bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1649{
1650 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1651 return it != mAssistantUids.end();
1652}
1653
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001654void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1655 mActiveAssistantUids = activeUids;
1656}
1657
1658bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1659{
1660 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1661 mActiveAssistantUids.end(), uid);
1662 return it != mActiveAssistantUids.end();
1663}
1664
Oscar Azucena829d90d2022-01-28 17:17:56 -08001665void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1666 const size_t SIZE = 256;
1667 char buffer[SIZE];
1668 String8 result;
1669 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1670 snprintf(buffer, SIZE, "\t%s: \n", title);
1671 result.append(buffer);
1672 int counter = 0;
1673 if (uids.empty()) {
1674 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1675 result.append(buffer);
1676 return;
1677 }
1678 for (const auto &uid : uids) {
1679 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1680 result.append(buffer);
1681 }
1682 };
1683
1684 snprintf(buffer, SIZE, "UID Policy:\n");
1685 result.append(buffer);
1686 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1687 result.append(buffer);
1688
1689 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001690 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001691
1692 appendUidsToResult("Accessibility UIDs", mA11yUids);
1693
1694 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1695 result.append(buffer);
1696
1697 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1698 result.append(buffer);
1699
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001700 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001701}
1702
Michael Groovercfd28302018-12-11 19:16:46 -08001703// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1704void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1705 SensorPrivacyManager spm;
1706 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1707 spm.addSensorPrivacyListener(this);
1708}
1709
1710void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1711 SensorPrivacyManager spm;
1712 spm.removeSensorPrivacyListener(this);
1713}
1714
1715bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1716 return mSensorPrivacyEnabled;
1717}
1718
Evan Seversond8dc6832022-01-27 10:47:03 -08001719binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1720 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001721 mSensorPrivacyEnabled = enabled;
1722 sp<AudioPolicyService> service = mService.promote();
1723 if (service != nullptr) {
1724 service->updateUidStates();
1725 }
1726 return binder::Status::ok();
1727}
1728
Mathias Agopian65ab4712010-07-14 17:59:35 -07001729// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1730
Eric Laurentbfb1b832013-01-07 09:53:42 -08001731AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1732 const wp<AudioPolicyService>& service)
1733 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001734{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001735}
1736
1737
1738AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1739{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001740 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001741 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001742 }
1743 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001744}
1745
1746void AudioPolicyService::AudioCommandThread::onFirstRef()
1747{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001748 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001749}
1750
1751bool AudioPolicyService::AudioCommandThread::threadLoop()
1752{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001753 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001754
Andy Hung79eacdb2023-11-30 19:34:24 -08001755 audio_utils::unique_lock ul(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001756 while (!exitPending())
1757 {
Eric Laurent59a89232014-06-08 14:14:17 -07001758 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001759 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001760 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001761 nsecs_t curTime = systemTime();
1762 // commands are sorted by increasing time stamp: execute them from index 0 and up
1763 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001764 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001765 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001766 if (mAudioCommands.isEmpty()) {
1767 ++numTimesBecameEmpty;
1768 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001769 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001770
1771 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001772 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001773 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001774 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001775 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001776 ul.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001777 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1778 data->mVolume,
1779 data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001780 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001781 }break;
1782 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001783 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001784 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001785 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001786 ul.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001787 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hung79eacdb2023-11-30 19:34:24 -08001788 ul.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001789 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001790 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001791 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001792 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001793 data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001794 ul.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001795 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001796 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001797 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001798 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001799 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001800 ALOGV("AudioCommandThread() processing stop output portId %d",
1801 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001802 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001803 if (svc == 0) {
1804 break;
1805 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001806 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001807 svc->doStopOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001808 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001809 }break;
1810 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001811 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001812 ALOGV("AudioCommandThread() processing release output portId %d",
1813 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001814 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001815 if (svc == 0) {
1816 break;
1817 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001818 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001819 svc->doReleaseOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001820 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001821 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001822 case CREATE_AUDIO_PATCH: {
1823 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1824 ALOGV("AudioCommandThread() processing create audio patch");
1825 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1826 if (af == 0) {
1827 command->mStatus = PERMISSION_DENIED;
1828 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001829 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001830 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001831 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001832 }
1833 } break;
1834 case RELEASE_AUDIO_PATCH: {
1835 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1836 ALOGV("AudioCommandThread() processing release audio patch");
1837 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1838 if (af == 0) {
1839 command->mStatus = PERMISSION_DENIED;
1840 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001841 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001842 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001843 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001844 }
1845 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001846 case UPDATE_AUDIOPORT_LIST: {
1847 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001848 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001849 if (svc == 0) {
1850 break;
1851 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001852 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001853 svc->doOnAudioPortListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001854 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001855 }break;
1856 case UPDATE_AUDIOPATCH_LIST: {
1857 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07001858 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001859 if (svc == 0) {
1860 break;
1861 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001862 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001863 svc->doOnAudioPatchListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001864 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001865 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01001866 case CHANGED_AUDIOVOLUMEGROUP: {
1867 AudioVolumeGroupData *data =
1868 static_cast<AudioVolumeGroupData *>(command->mParam.get());
1869 ALOGV("AudioCommandThread() processing update audio volume group");
1870 svc = mService.promote();
1871 if (svc == 0) {
1872 break;
1873 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001874 ul.unlock();
François Gaffiecfe17322018-11-07 13:41:29 +01001875 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
Andy Hung79eacdb2023-11-30 19:34:24 -08001876 ul.lock();
François Gaffiecfe17322018-11-07 13:41:29 +01001877 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07001878 case SET_AUDIOPORT_CONFIG: {
1879 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
1880 ALOGV("AudioCommandThread() processing set port config");
1881 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1882 if (af == 0) {
1883 command->mStatus = PERMISSION_DENIED;
1884 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001885 ul.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07001886 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hung79eacdb2023-11-30 19:34:24 -08001887 ul.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07001888 }
1889 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07001890 case DYN_POLICY_MIX_STATE_UPDATE: {
1891 DynPolicyMixStateUpdateData *data =
1892 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001893 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001894 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07001895 svc = mService.promote();
1896 if (svc == 0) {
1897 break;
1898 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001899 ul.unlock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001900 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
Andy Hung79eacdb2023-11-30 19:34:24 -08001901 ul.lock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001902 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001903 case RECORDING_CONFIGURATION_UPDATE: {
1904 RecordingConfigurationUpdateData *data =
1905 (RecordingConfigurationUpdateData *)command->mParam.get();
1906 ALOGV("AudioCommandThread() processing recording configuration update");
1907 svc = mService.promote();
1908 if (svc == 0) {
1909 break;
1910 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001911 ul.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001912 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08001913 &data->mClientConfig, data->mClientEffects,
1914 &data->mDeviceConfig, data->mEffects,
1915 data->mPatchHandle, data->mSource);
Andy Hung79eacdb2023-11-30 19:34:24 -08001916 ul.lock();
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001917 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001918 case SET_EFFECT_SUSPENDED: {
1919 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
1920 ALOGV("AudioCommandThread() processing set effect suspended");
1921 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1922 if (af != 0) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001923 ul.unlock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001924 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
Andy Hung79eacdb2023-11-30 19:34:24 -08001925 ul.lock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001926 }
1927 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001928 case AUDIO_MODULES_UPDATE: {
1929 ALOGV("AudioCommandThread() processing audio modules update");
1930 svc = mService.promote();
1931 if (svc == 0) {
1932 break;
1933 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001934 ul.unlock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001935 svc->doOnNewAudioModulesAvailable();
Andy Hung79eacdb2023-11-30 19:34:24 -08001936 ul.lock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001937 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001938 case ROUTING_UPDATED: {
1939 ALOGV("AudioCommandThread() processing routing update");
1940 svc = mService.promote();
1941 if (svc == 0) {
1942 break;
1943 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001944 ul.unlock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001945 svc->doOnRoutingUpdated();
Andy Hung79eacdb2023-11-30 19:34:24 -08001946 ul.lock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001947 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001948
Eric Laurented726cc2021-07-01 14:26:41 +02001949 case UPDATE_UID_STATES: {
1950 ALOGV("AudioCommandThread() processing updateUID states");
1951 svc = mService.promote();
1952 if (svc == 0) {
1953 break;
1954 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001955 ul.unlock();
Eric Laurented726cc2021-07-01 14:26:41 +02001956 svc->updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -08001957 ul.lock();
Eric Laurented726cc2021-07-01 14:26:41 +02001958 } break;
1959
Eric Laurent15903592022-02-24 20:44:36 +01001960 case CHECK_SPATIALIZER_OUTPUT: {
1961 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02001962 svc = mService.promote();
1963 if (svc == 0) {
1964 break;
1965 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001966 ul.unlock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02001967 svc->doOnCheckSpatializer();
Andy Hung79eacdb2023-11-30 19:34:24 -08001968 ul.lock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02001969 } break;
1970
Eric Laurent15903592022-02-24 20:44:36 +01001971 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
1972 ALOGV("AudioCommandThread() processing update spatializer tracks");
1973 svc = mService.promote();
1974 if (svc == 0) {
1975 break;
1976 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001977 ul.unlock();
Eric Laurent15903592022-02-24 20:44:36 +01001978 svc->doOnUpdateActiveSpatializerTracks();
Andy Hung79eacdb2023-11-30 19:34:24 -08001979 ul.lock();
Eric Laurent15903592022-02-24 20:44:36 +01001980 } break;
1981
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00001982 case VOL_RANGE_INIT_REQUEST: {
1983 ALOGV("AudioCommandThread() processing volume range init request");
1984 svc = mService.promote();
1985 if (svc == 0) {
1986 break;
1987 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001988 ul.unlock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00001989 svc->doOnVolumeRangeInitRequest();
Andy Hung79eacdb2023-11-30 19:34:24 -08001990 ul.lock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00001991 } break;
1992
Mathias Agopian65ab4712010-07-14 17:59:35 -07001993 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00001994 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001995 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001996 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001997 audio_utils::lock_guard _l(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07001998 if (command->mWaitStatus) {
1999 command->mWaitStatus = false;
Andy Hung79eacdb2023-11-30 19:34:24 -08002000 command->mCond.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002001 }
2002 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002003 waitTime = -1;
Andy Hung79eacdb2023-11-30 19:34:24 -08002004 // release ul before releasing strong reference on the service as
Zach Janga754b4f2015-10-27 01:29:34 +00002005 // AudioPolicyService destructor calls AudioCommandThread::exit() which
Andy Hung79eacdb2023-11-30 19:34:24 -08002006 // acquires ul.
2007 ul.unlock();
Zach Janga754b4f2015-10-27 01:29:34 +00002008 svc.clear();
Andy Hung79eacdb2023-11-30 19:34:24 -08002009 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002010 } else {
2011 waitTime = mAudioCommands[0]->mTime - curTime;
2012 break;
2013 }
2014 }
Zach Janga754b4f2015-10-27 01:29:34 +00002015
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002016 // release delayed commands wake lock as many times as we made the queue is
2017 // empty during popping.
2018 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002019 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002020 }
2021
2022 // At this stage we have either an empty command queue or the first command in the queue
2023 // has a finite delay. So unless we are exiting it is safe to wait.
2024 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002025 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002026 if (waitTime == -1) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002027 mWaitWorkCV.wait(ul);
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002028 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002029 // discard return value.
2030 mWaitWorkCV.wait_for(ul, std::chrono::nanoseconds(waitTime));
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002031 }
Eric Laurent59a89232014-06-08 14:14:17 -07002032 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002033 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002034 // release delayed commands wake lock before quitting
2035 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002036 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002037 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002038 return false;
2039}
2040
2041status_t AudioPolicyService::AudioCommandThread::dump(int fd)
Andy Hung79eacdb2023-11-30 19:34:24 -08002042NO_THREAD_SAFETY_ANALYSIS // trylock
Mathias Agopian65ab4712010-07-14 17:59:35 -07002043{
2044 const size_t SIZE = 256;
2045 char buffer[SIZE];
2046 String8 result;
2047
Andy Hung79eacdb2023-11-30 19:34:24 -08002048 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002049 if (!locked) {
2050 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002051 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002052 }
2053
2054 snprintf(buffer, SIZE, "- Commands:\n");
2055 result = String8(buffer);
2056 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002057 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002058 mAudioCommands[i]->dump(buffer, SIZE);
2059 result.append(buffer);
2060 }
2061 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002062 if (mLastCommand != 0) {
2063 mLastCommand->dump(buffer, SIZE);
2064 result.append(buffer);
2065 } else {
2066 result.append(" none\n");
2067 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002068
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002069 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002070
Andy Hung79eacdb2023-11-30 19:34:24 -08002071 dumpReleaseLock(mMutex, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002072
2073 return NO_ERROR;
2074}
2075
Glenn Kastenfff6d712012-01-12 16:38:12 -08002076status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002077 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002078 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002079 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002080{
Eric Laurent0ede8922014-05-09 18:04:42 -07002081 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002082 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002083 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002084 data->mStream = stream;
2085 data->mVolume = volume;
2086 data->mIO = output;
2087 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002088 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002089 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002090 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002091 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002092}
2093
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002094status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002095 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002096 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002097{
Eric Laurent0ede8922014-05-09 18:04:42 -07002098 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002099 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002100 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002101 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002102 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002103 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002104 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002105 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002106 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002107 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002108}
2109
2110status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2111{
Eric Laurent0ede8922014-05-09 18:04:42 -07002112 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002113 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002114 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002115 data->mVolume = volume;
2116 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002117 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002118 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002119 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002120}
2121
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002122void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2123 audio_session_t sessionId,
2124 bool suspended)
2125{
2126 sp<AudioCommand> command = new AudioCommand();
2127 command->mCommand = SET_EFFECT_SUSPENDED;
2128 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2129 data->mEffectId = effectId;
2130 data->mSessionId = sessionId;
2131 data->mSuspended = suspended;
2132 command->mParam = data;
2133 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2134 effectId, sessionId, suspended);
2135 sendCommand(command);
2136}
2137
2138
Eric Laurentd7fe0862018-07-14 16:48:01 -07002139void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002140{
Eric Laurent0ede8922014-05-09 18:04:42 -07002141 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002142 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002143 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002144 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002145 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002146 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002147 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002148}
2149
Eric Laurentd7fe0862018-07-14 16:48:01 -07002150void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002151{
Eric Laurent0ede8922014-05-09 18:04:42 -07002152 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002153 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002154 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002155 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002156 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002157 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002158 sendCommand(command);
2159}
2160
Eric Laurent951f4552014-05-20 10:48:17 -07002161status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2162 const struct audio_patch *patch,
2163 audio_patch_handle_t *handle,
2164 int delayMs)
2165{
2166 status_t status = NO_ERROR;
2167
2168 sp<AudioCommand> command = new AudioCommand();
2169 command->mCommand = CREATE_AUDIO_PATCH;
2170 CreateAudioPatchData *data = new CreateAudioPatchData();
2171 data->mPatch = *patch;
2172 data->mHandle = *handle;
2173 command->mParam = data;
2174 command->mWaitStatus = true;
2175 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2176 status = sendCommand(command, delayMs);
2177 if (status == NO_ERROR) {
2178 *handle = data->mHandle;
2179 }
2180 return status;
2181}
2182
2183status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2184 int delayMs)
2185{
2186 sp<AudioCommand> command = new AudioCommand();
2187 command->mCommand = RELEASE_AUDIO_PATCH;
2188 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2189 data->mHandle = handle;
2190 command->mParam = data;
2191 command->mWaitStatus = true;
2192 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2193 return sendCommand(command, delayMs);
2194}
2195
Eric Laurentb52c1522014-05-20 11:27:36 -07002196void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2197{
2198 sp<AudioCommand> command = new AudioCommand();
2199 command->mCommand = UPDATE_AUDIOPORT_LIST;
2200 ALOGV("AudioCommandThread() adding update audio port list");
2201 sendCommand(command);
2202}
2203
Eric Laurented726cc2021-07-01 14:26:41 +02002204void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2205{
2206 sp<AudioCommand> command = new AudioCommand();
2207 command->mCommand = UPDATE_UID_STATES;
2208 ALOGV("AudioCommandThread() adding update UID states");
2209 sendCommand(command);
2210}
2211
Eric Laurentb52c1522014-05-20 11:27:36 -07002212void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2213{
2214 sp<AudioCommand>command = new AudioCommand();
2215 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2216 ALOGV("AudioCommandThread() adding update audio patch list");
2217 sendCommand(command);
2218}
2219
François Gaffiecfe17322018-11-07 13:41:29 +01002220void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2221 int flags)
2222{
2223 sp<AudioCommand>command = new AudioCommand();
2224 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2225 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2226 data->mGroup = group;
2227 data->mFlags = flags;
2228 command->mParam = data;
2229 ALOGV("AudioCommandThread() adding audio volume group changed");
2230 sendCommand(command);
2231}
2232
Eric Laurente1715a42014-05-20 11:30:42 -07002233status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2234 const struct audio_port_config *config, int delayMs)
2235{
2236 sp<AudioCommand> command = new AudioCommand();
2237 command->mCommand = SET_AUDIOPORT_CONFIG;
2238 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2239 data->mConfig = *config;
2240 command->mParam = data;
2241 command->mWaitStatus = true;
2242 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2243 return sendCommand(command, delayMs);
2244}
2245
Jean-Michel Trivide801052015-04-14 19:10:14 -07002246void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002247 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002248{
2249 sp<AudioCommand> command = new AudioCommand();
2250 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2251 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2252 data->mRegId = regId;
2253 data->mState = state;
2254 command->mParam = data;
2255 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002256 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002257 sendCommand(command);
2258}
2259
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002260void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002261 int event,
2262 const record_client_info_t *clientInfo,
2263 const audio_config_base_t *clientConfig,
2264 std::vector<effect_descriptor_t> clientEffects,
2265 const audio_config_base_t *deviceConfig,
2266 std::vector<effect_descriptor_t> effects,
2267 audio_patch_handle_t patchHandle,
2268 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002269{
2270 sp<AudioCommand>command = new AudioCommand();
2271 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2272 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2273 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002274 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002275 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002276 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002277 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002278 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002279 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002280 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002281 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002282 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2283 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002284 sendCommand(command);
2285}
2286
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002287void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2288{
2289 sp<AudioCommand> command = new AudioCommand();
2290 command->mCommand = AUDIO_MODULES_UPDATE;
2291 sendCommand(command);
2292}
2293
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002294void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2295{
2296 sp<AudioCommand>command = new AudioCommand();
2297 command->mCommand = ROUTING_UPDATED;
2298 ALOGV("AudioCommandThread() adding routing update");
2299 sendCommand(command);
2300}
2301
Eric Laurent81dd0f52021-07-05 11:54:40 +02002302void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2303{
2304 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002305 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002306 ALOGV("AudioCommandThread() adding check spatializer");
2307 sendCommand(command);
2308}
2309
Eric Laurent15903592022-02-24 20:44:36 +01002310void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2311{
2312 sp<AudioCommand>command = new AudioCommand();
2313 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2314 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2315 sendCommand(command);
2316}
2317
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002318void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2319{
2320 sp<AudioCommand>command = new AudioCommand();
2321 command->mCommand = VOL_RANGE_INIT_REQUEST;
2322 ALOGV("AudioCommandThread() adding volume range init request");
2323 sendCommand(command);
2324}
2325
Eric Laurent0ede8922014-05-09 18:04:42 -07002326status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2327{
2328 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002329 audio_utils::lock_guard _l(mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002330 insertCommand_l(command, delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002331 mWaitWorkCV.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002332 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002333 audio_utils::unique_lock ul(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002334 while (command->mWaitStatus) {
2335 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002336 if (command->mCond.wait_for(
Andy Hung02ea2a02024-01-25 17:02:30 -08002337 ul, std::chrono::nanoseconds(timeOutNs), getTid()) == std::cv_status::timeout) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002338 command->mStatus = TIMED_OUT;
2339 command->mWaitStatus = false;
2340 }
2341 }
2342 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002343}
2344
Andy Hung79eacdb2023-11-30 19:34:24 -08002345// insertCommand_l() must be called with mMutex held
Eric Laurent0ede8922014-05-09 18:04:42 -07002346void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002347{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002348 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002349 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002350 command->mTime = systemTime() + milliseconds(delayMs);
2351
2352 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002353 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002354 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002355 }
2356
2357 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002358 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002359 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002360 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2361 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002362
2363 // create audio patch or release audio patch commands are equivalent
2364 // with regard to filtering
2365 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2366 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2367 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2368 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2369 continue;
2370 }
2371 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002372
2373 switch (command->mCommand) {
2374 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002375 ParametersData *data = (ParametersData *)command->mParam.get();
2376 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002377 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002378 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002379 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002380 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2381 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2382 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002383 String8 key;
2384 String8 value;
2385 param.getAt(j, key, value);
2386 for (size_t k = 0; k < param2.size(); k++) {
2387 String8 key2;
2388 String8 value2;
2389 param2.getAt(k, key2, value2);
2390 if (key2 == key) {
2391 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002392 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002393 break;
2394 }
2395 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002396 }
2397 // if all keys have been filtered out, remove the command.
2398 // otherwise, update the key value pairs
2399 if (param2.size() == 0) {
2400 removedCommands.add(command2);
2401 } else {
2402 data2->mKeyValuePairs = param2.toString();
2403 }
Eric Laurent21e54562013-09-23 12:08:05 -07002404 command->mTime = command2->mTime;
2405 // force delayMs to non 0 so that code below does not request to wait for
2406 // command status as the command is now delayed
2407 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002408 } break;
2409
2410 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002411 VolumeData *data = (VolumeData *)command->mParam.get();
2412 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002413 if (data->mIO != data2->mIO) break;
2414 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002415 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002416 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002417 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002418 command->mTime = command2->mTime;
2419 // force delayMs to non 0 so that code below does not request to wait for
2420 // command status as the command is now delayed
2421 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002422 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002423
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002424 case SET_VOICE_VOLUME: {
2425 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2426 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2427 ALOGV("Filtering out voice volume command value %f replaced by %f",
2428 data2->mVolume, data->mVolume);
2429 removedCommands.add(command2);
2430 command->mTime = command2->mTime;
2431 // force delayMs to non 0 so that code below does not request to wait for
2432 // command status as the command is now delayed
2433 delayMs = 1;
2434 } break;
2435
Eric Laurente45b48a2014-09-04 16:40:57 -07002436 case CREATE_AUDIO_PATCH:
2437 case RELEASE_AUDIO_PATCH: {
2438 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002439 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002440 if (command->mCommand == CREATE_AUDIO_PATCH) {
2441 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002442 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002443 } else {
2444 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002445 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002446 }
2447 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002448 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002449 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2450 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002451 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002452 } else {
2453 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002454 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002455 }
2456 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002457 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2458 same output. */
2459 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2460 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2461 bool isOutputDiff = false;
2462 if (patch.num_sources == patch2.num_sources) {
2463 for (unsigned count = 0; count < patch.num_sources; count++) {
2464 if (patch.sources[count].id != patch2.sources[count].id) {
2465 isOutputDiff = true;
2466 break;
2467 }
2468 }
2469 if (isOutputDiff)
2470 break;
2471 }
2472 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002473 ALOGV("Filtering out %s audio patch command for handle %d",
2474 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2475 removedCommands.add(command2);
2476 command->mTime = command2->mTime;
2477 // force delayMs to non 0 so that code below does not request to wait for
2478 // command status as the command is now delayed
2479 delayMs = 1;
2480 } break;
2481
Jean-Michel Trivide801052015-04-14 19:10:14 -07002482 case DYN_POLICY_MIX_STATE_UPDATE: {
2483
2484 } break;
2485
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002486 case RECORDING_CONFIGURATION_UPDATE: {
2487
2488 } break;
2489
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002490 case ROUTING_UPDATED: {
2491
2492 } break;
2493
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002494 case VOL_RANGE_INIT_REQUEST: {
2495 // command may come from different requests, do not filter
2496 } break;
2497
Mathias Agopian65ab4712010-07-14 17:59:35 -07002498 default:
2499 break;
2500 }
2501 }
2502
2503 // remove filtered commands
2504 for (size_t j = 0; j < removedCommands.size(); j++) {
2505 // removed commands always have time stamps greater than current command
2506 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002507 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002508 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002509 mAudioCommands.removeAt(k);
2510 break;
2511 }
2512 }
2513 }
2514 removedCommands.clear();
2515
Eric Laurentaa79bef2015-01-15 14:33:51 -08002516 // Disable wait for status if delay is not 0.
2517 // Except for create audio patch command because the returned patch handle
2518 // is needed by audio policy manager
2519 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002520 command->mWaitStatus = false;
2521 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002522
Mathias Agopian65ab4712010-07-14 17:59:35 -07002523 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002524 ALOGV("inserting command: %d at index %zd, num commands %zu",
2525 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002526 mAudioCommands.insertAt(command, i + 1);
2527}
2528
2529void AudioPolicyService::AudioCommandThread::exit()
2530{
Steve Block3856b092011-10-20 11:56:00 +01002531 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002532 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002533 audio_utils::lock_guard _l(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002534 requestExit();
Andy Hung79eacdb2023-11-30 19:34:24 -08002535 mWaitWorkCV.notify_one();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002536 }
Zach Janga754b4f2015-10-27 01:29:34 +00002537 // Note that we can call it from the thread loop if all other references have been released
2538 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002539 requestExitAndWait();
2540}
2541
2542void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2543{
2544 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2545 mCommand,
2546 (int)ns2s(mTime),
2547 (int)ns2ms(mTime)%1000,
2548 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002549 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002550}
2551
Dima Zavinfce7a472011-04-19 22:30:36 -07002552/******* helpers for the service_ops callbacks defined below *********/
2553void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2554 const char *keyValuePairs,
2555 int delayMs)
2556{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002557 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002558 delayMs);
2559}
2560
2561int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2562 float volume,
2563 audio_io_handle_t output,
2564 int delayMs)
2565{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002566 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002567 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002568}
2569
Dima Zavinfce7a472011-04-19 22:30:36 -07002570int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2571{
2572 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2573}
2574
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002575void AudioPolicyService::setEffectSuspended(int effectId,
2576 audio_session_t sessionId,
2577 bool suspended)
2578{
2579 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2580}
2581
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002582Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002583{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002584 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002585 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002586}
2587
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002588
Dima Zavinfce7a472011-04-19 22:30:36 -07002589extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002590audio_module_handle_t aps_load_hw_module(void *service __unused,
2591 const char *name);
2592audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002593 audio_devices_t *pDevices,
2594 uint32_t *pSamplingRate,
2595 audio_format_t *pFormat,
2596 audio_channel_mask_t *pChannelMask,
2597 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002598 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002599
Eric Laurent2d388ec2014-03-07 13:25:54 -08002600audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002601 audio_module_handle_t module,
2602 audio_devices_t *pDevices,
2603 uint32_t *pSamplingRate,
2604 audio_format_t *pFormat,
2605 audio_channel_mask_t *pChannelMask,
2606 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002607 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002608 const audio_offload_info_t *offloadInfo);
2609audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002610 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002611 audio_io_handle_t output2);
2612int aps_close_output(void *service __unused, audio_io_handle_t output);
2613int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2614int aps_restore_output(void *service __unused, audio_io_handle_t output);
2615audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002616 audio_devices_t *pDevices,
2617 uint32_t *pSamplingRate,
2618 audio_format_t *pFormat,
2619 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002620 audio_in_acoustics_t acoustics __unused);
2621audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002622 audio_module_handle_t module,
2623 audio_devices_t *pDevices,
2624 uint32_t *pSamplingRate,
2625 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002626 audio_channel_mask_t *pChannelMask);
2627int aps_close_input(void *service __unused, audio_io_handle_t input);
2628int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002629int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002630 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002631 audio_io_handle_t dst_output);
2632char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2633 const char *keys);
2634void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2635 const char *kv_pairs, int delay_ms);
2636int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002637 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002638 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002639int aps_set_voice_volume(void *service, float volume, int delay_ms);
2640};
Dima Zavinfce7a472011-04-19 22:30:36 -07002641
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002642} // namespace android