blob: cc67481c3d7716e507191fe51cbb3d5c5a5a1d31 [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) \
Vlad Popa87e0e582024-05-20 18:49:20 -070082BINDER_METHOD_ENTRY(setDeviceAbsoluteVolumeEnabled) \
Andy Hungc747c532022-03-07 21:41:14 -080083BINDER_METHOD_ENTRY(initStreamVolume) \
84BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
85BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
86BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
87BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
88BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
90BINDER_METHOD_ENTRY(getStrategyForStream) \
91BINDER_METHOD_ENTRY(getDevicesForAttributes) \
92BINDER_METHOD_ENTRY(getOutputForEffect) \
93BINDER_METHOD_ENTRY(registerEffect) \
94BINDER_METHOD_ENTRY(unregisterEffect) \
95BINDER_METHOD_ENTRY(setEffectEnabled) \
96BINDER_METHOD_ENTRY(moveEffectsToIo) \
97BINDER_METHOD_ENTRY(isStreamActive) \
98BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
99BINDER_METHOD_ENTRY(isSourceActive) \
100BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
101BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
102BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
103BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
104BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
105BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
106BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
107BINDER_METHOD_ENTRY(getOffloadSupport) \
108BINDER_METHOD_ENTRY(isDirectOutputSupported) \
109BINDER_METHOD_ENTRY(listAudioPorts) \
110BINDER_METHOD_ENTRY(getAudioPort) \
111BINDER_METHOD_ENTRY(createAudioPatch) \
112BINDER_METHOD_ENTRY(releaseAudioPatch) \
113BINDER_METHOD_ENTRY(listAudioPatches) \
114BINDER_METHOD_ENTRY(setAudioPortConfig) \
115BINDER_METHOD_ENTRY(registerClient) \
116BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
117BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
118BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
119BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
120BINDER_METHOD_ENTRY(getPhoneState) \
121BINDER_METHOD_ENTRY(registerPolicyMixes) \
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200122BINDER_METHOD_ENTRY(updatePolicyMixes) \
Andy Hungc747c532022-03-07 21:41:14 -0800123BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
124BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
125BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
126BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
127BINDER_METHOD_ENTRY(startAudioSource) \
128BINDER_METHOD_ENTRY(stopAudioSource) \
129BINDER_METHOD_ENTRY(setMasterMono) \
130BINDER_METHOD_ENTRY(getMasterMono) \
131BINDER_METHOD_ENTRY(getStreamVolumeDB) \
132BINDER_METHOD_ENTRY(getSurroundFormats) \
133BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
134BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
135BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
136BINDER_METHOD_ENTRY(setAssistantServicesUids) \
137BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
138BINDER_METHOD_ENTRY(setA11yServicesUids) \
139BINDER_METHOD_ENTRY(setCurrentImeUid) \
140BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
141BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800142BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800143BINDER_METHOD_ENTRY(listAudioProductStrategies) \
144BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
145BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
146BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
147BINDER_METHOD_ENTRY(setRttEnabled) \
148BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
149BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
150BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000151BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800152BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
153BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
157BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
158BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
159BINDER_METHOD_ENTRY(getSpatializer) \
160BINDER_METHOD_ENTRY(canBeSpatialized) \
161BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000162BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
163BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
164BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
165BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
166BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100167BINDER_METHOD_ENTRY(getRegisteredPolicyMixes) \
Atneya Nair9f91a5e2024-05-09 16:25:05 -0700168BINDER_METHOD_ENTRY(getPermissionController) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100169 \
Andy Hungc747c532022-03-07 21:41:14 -0800170// singleton for Binder Method Statistics for IAudioPolicyService
171static auto& getIAudioPolicyServiceStatistics() {
172 using Code = int;
173
174#pragma push_macro("BINDER_METHOD_ENTRY")
175#undef BINDER_METHOD_ENTRY
176#define BINDER_METHOD_ENTRY(ENTRY) \
177 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
178
179 static mediautils::MethodStatistics<Code> methodStatistics{
180 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
181 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
182 };
183#pragma pop_macro("BINDER_METHOD_ENTRY")
184
185 return methodStatistics;
186}
187
Mathias Agopian65ab4712010-07-14 17:59:35 -0700188// ----------------------------------------------------------------------------
189
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530190static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
191{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700192 AudioPolicyManager *apm = nullptr;
193 media::AudioPolicyConfig apmConfig;
194 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
195 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
196 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
197 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
198 "Only default engine is currently supported with the AIDL HAL");
199 apm = new AudioPolicyManager(config,
200 loadApmEngineLibraryAndCreateEngine(
201 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
202 clientInterface);
203 } else {
204 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
205 apm = new AudioPolicyManager(config,
206 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
207 clientInterface);
208 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530209 status_t status = apm->initialize();
210 if (status != NO_ERROR) {
211 delete apm;
212 apm = nullptr;
213 }
214 return apm;
215}
216
217static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
218{
219 delete interface;
220}
221// ----------------------------------------------------------------------------
222
Mathias Agopian65ab4712010-07-14 17:59:35 -0700223AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700224 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700225 mAudioPolicyManager(NULL),
226 mAudioPolicyClient(NULL),
227 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530228 mCaptureStateNotifier(false),
229 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100230 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
Atneya Nair9f91a5e2024-05-09 16:25:05 -0700231 mUsecaseValidator(media::createUsecaseValidator()),
232 mPermissionController(sp<NativePermissionController>::make())
233{
Andy Hung225aef62022-12-06 16:33:20 -0800234 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Andy Hung58b01b12024-03-26 18:04:29 -0700235 setInheritRt(true);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530236}
237
238void AudioPolicyService::loadAudioPolicyManager()
239{
240 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
241 if (mLibraryHandle != nullptr) {
242 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
243 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
244 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
245 const char *lastError = dlerror();
246 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
247 __func__, lastError != nullptr ? lastError : "no error");
248
249 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
250 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
251 lastError = dlerror();
252 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
253 __func__, lastError != nullptr ? lastError : "no error");
254 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
255 unloadAudioPolicyManager();
256 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
257 }
258 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700259}
260
261void AudioPolicyService::onFirstRef()
262{
Andy Hungd47aca22022-03-15 11:50:51 -0700263 // Log an AudioPolicy "constructor" mediametrics event on first ref.
264 // This records the time it takes to load the audio modules and devices.
265 mediametrics::Defer defer([beginNs = systemTime()] {
266 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
267 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
268 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
269 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700270 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800271 audio_utils::lock_guard _l(mMutex);
Eric Laurent93575202011-01-18 18:39:02 -0800272
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700273 // start audio commands thread
274 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
275 // start output activity command thread
276 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700277
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700278 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530279
280 loadAudioPolicyManager();
281 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700282 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200283
bryant_liuba2b4392014-06-11 16:49:30 +0800284 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000285 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
Andy Hungd3595ed2023-12-19 15:34:46 -0800286 auto audioPolicyEffects = sp<AudioPolicyEffects>::make(effectsFactoryHal);
287 auto uidPolicy = sp<UidPolicy>::make(this);
288 auto sensorPrivacyPolicy = sp<SensorPrivacyPolicy>::make(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700289 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800290 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700291 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000292 mUidPolicy = uidPolicy;
293 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700294 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000295 uidPolicy->registerSelf();
296 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200297
Eric Laurent81dd0f52021-07-05 11:54:40 +0200298 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200299 if (mAudioPolicyManager != nullptr) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800300 audio_utils::lock_guard _l(mMutex);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200301 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
302 AudioDeviceTypeAddrVector devices;
303 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
304 if (hasSpatializer) {
Andy Hung1040da52023-12-06 20:59:06 -0800305 // Unlock as Spatializer::create() will use the callback and acquire the
306 // AudioPolicyService_Mutex.
Andy Hung79eacdb2023-11-30 19:34:24 -0800307 mMutex.unlock();
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000308 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Andy Hung79eacdb2023-11-30 19:34:24 -0800309 mMutex.lock();
Eric Laurent52b0bd52021-09-27 15:25:40 +0200310 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700311 if (mSpatializer == nullptr) {
312 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
313 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
314 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
315 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200316 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200317 AudioSystem::audioPolicyReady();
Andy Hungb08b3752024-01-09 19:05:23 -0800318}
319
Atneya Nair87818d32024-05-23 10:59:30 -0700320const IPermissionProvider& AudioPolicyService::getPermissionProvider() const {
321 return *mPermissionController;
322}
323
Andy Hungb08b3752024-01-09 19:05:23 -0800324void AudioPolicyService::onAudioSystemReady() {
325 sp<AudioPolicyEffects> audioPolicyEffects;
326 {
327 audio_utils::lock_guard _l(mMutex);
328
329 audioPolicyEffects = mAudioPolicyEffects;
330 }
331 audioPolicyEffects->initDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700332}
333
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530334void AudioPolicyService::unloadAudioPolicyManager()
335{
336 ALOGV("%s ", __func__);
337 if (mLibraryHandle != nullptr) {
338 dlclose(mLibraryHandle);
339 }
340 mLibraryHandle = nullptr;
341 mCreateAudioPolicyManager = nullptr;
342 mDestroyAudioPolicyManager = nullptr;
343}
344
Mathias Agopian65ab4712010-07-14 17:59:35 -0700345AudioPolicyService::~AudioPolicyService()
346{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700347 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700348 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700349
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530350 mDestroyAudioPolicyManager(mAudioPolicyManager);
351 unloadAudioPolicyManager();
352
Eric Laurentdce54a12014-03-10 12:19:46 -0700353 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700354
355 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800356 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800357
358 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800359 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000360
361 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800362 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700363}
364
365// A notification client is always registered by AudioSystem when the client process
366// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800367Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700368{
Eric Laurent12590252015-08-21 18:40:20 -0700369 if (client == 0) {
370 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800371 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700372 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800373 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700374
375 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800376 pid_t pid = IPCThreadState::self()->getCallingPid();
377 int64_t token = ((int64_t)uid<<32) | pid;
378
379 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700380 sp<NotificationClient> notificationClient = new NotificationClient(this,
381 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800382 uid,
383 pid);
384 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700385
luochaojiang908c7d72018-06-21 14:58:04 +0800386 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700387
Marco Nelissenf8880202014-11-14 07:58:25 -0800388 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700389 binder->linkToDeath(notificationClient);
390 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800391 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700392}
393
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800394Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700395{
Andy Hung79eacdb2023-11-30 19:34:24 -0800396 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurente8726fe2015-06-26 09:39:24 -0700397
398 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800399 pid_t pid = IPCThreadState::self()->getCallingPid();
400 int64_t token = ((int64_t)uid<<32) | pid;
401
402 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800403 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700404 }
luochaojiang908c7d72018-06-21 14:58:04 +0800405 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800406 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700407}
408
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800409Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100410{
Andy Hung79eacdb2023-11-30 19:34:24 -0800411 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100412
413 uid_t uid = IPCThreadState::self()->getCallingUid();
414 pid_t pid = IPCThreadState::self()->getCallingPid();
415 int64_t token = ((int64_t)uid<<32) | pid;
416
417 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800418 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100419 }
420 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800421 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100422}
423
Eric Laurentb52c1522014-05-20 11:27:36 -0700424// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800425void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700426{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000427 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800428 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800429 audio_utils::lock_guard _l(mNotificationClientsMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800430 int64_t token = ((int64_t)uid<<32) | pid;
431 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800432 for (size_t i = 0; i < mNotificationClients.size(); i++) {
433 if (mNotificationClients.valueAt(i)->uid() == uid) {
434 hasSameUid = true;
435 break;
436 }
437 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000438 }
439 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800440 audio_utils::lock_guard _l(mMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800441 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700442 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700443 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700444 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800445 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700446}
447
448void AudioPolicyService::onAudioPortListUpdate()
449{
450 mOutputCommandThread->updateAudioPortListCommand();
451}
452
453void AudioPolicyService::doOnAudioPortListUpdate()
454{
Andy Hung79eacdb2023-11-30 19:34:24 -0800455 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700456 for (size_t i = 0; i < mNotificationClients.size(); i++) {
457 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
458 }
459}
460
461void AudioPolicyService::onAudioPatchListUpdate()
462{
463 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700464}
465
Eric Laurentb52c1522014-05-20 11:27:36 -0700466void AudioPolicyService::doOnAudioPatchListUpdate()
467{
Andy Hung79eacdb2023-11-30 19:34:24 -0800468 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700469 for (size_t i = 0; i < mNotificationClients.size(); i++) {
470 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
471 }
472}
473
François Gaffiecfe17322018-11-07 13:41:29 +0100474void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
475{
476 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
477}
478
479void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
480{
Andy Hung79eacdb2023-11-30 19:34:24 -0800481 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100482 for (size_t i = 0; i < mNotificationClients.size(); i++) {
483 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
484 }
485}
486
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700487void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700488{
489 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000490 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700491 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
492}
493
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700494void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700495{
Andy Hung79eacdb2023-11-30 19:34:24 -0800496 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700497 for (size_t i = 0; i < mNotificationClients.size(); i++) {
498 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
499 }
500}
501
Eric Laurenta9f86652018-11-28 17:23:11 -0800502void AudioPolicyService::onRecordingConfigurationUpdate(
503 int event,
504 const record_client_info_t *clientInfo,
505 const audio_config_base_t *clientConfig,
506 std::vector<effect_descriptor_t> clientEffects,
507 const audio_config_base_t *deviceConfig,
508 std::vector<effect_descriptor_t> effects,
509 audio_patch_handle_t patchHandle,
510 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800511{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800512 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800513 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800514}
515
Eric Laurenta9f86652018-11-28 17:23:11 -0800516void AudioPolicyService::doOnRecordingConfigurationUpdate(
517 int event,
518 const record_client_info_t *clientInfo,
519 const audio_config_base_t *clientConfig,
520 std::vector<effect_descriptor_t> clientEffects,
521 const audio_config_base_t *deviceConfig,
522 std::vector<effect_descriptor_t> effects,
523 audio_patch_handle_t patchHandle,
524 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800525{
Andy Hung79eacdb2023-11-30 19:34:24 -0800526 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800527 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800528 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800529 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800530 }
531}
532
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700533void AudioPolicyService::onRoutingUpdated()
534{
535 mOutputCommandThread->routingChangedCommand();
536}
537
538void AudioPolicyService::doOnRoutingUpdated()
539{
Andy Hung79eacdb2023-11-30 19:34:24 -0800540 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700541 for (size_t i = 0; i < mNotificationClients.size(); i++) {
542 mNotificationClients.valueAt(i)->onRoutingUpdated();
543 }
544}
545
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000546void AudioPolicyService::onVolumeRangeInitRequest()
547{
548 mOutputCommandThread->volRangeInitReqCommand();
549}
550
551void AudioPolicyService::doOnVolumeRangeInitRequest()
552{
Andy Hung79eacdb2023-11-30 19:34:24 -0800553 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000554 for (size_t i = 0; i < mNotificationClients.size(); i++) {
555 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
556 }
557}
558
Eric Laurent81dd0f52021-07-05 11:54:40 +0200559void AudioPolicyService::onCheckSpatializer()
560{
Andy Hung79eacdb2023-11-30 19:34:24 -0800561 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200562 onCheckSpatializer_l();
563}
564
565void AudioPolicyService::onCheckSpatializer_l()
566{
567 if (mSpatializer != nullptr) {
568 mOutputCommandThread->checkSpatializerCommand();
569 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200570}
571
572void AudioPolicyService::doOnCheckSpatializer()
573{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200574 ALOGV("%s mSpatializer %p level %d",
575 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200576
Eric Laurent39095982021-08-24 18:29:27 +0200577 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200578 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000579 if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200580 audio_io_handle_t currentOutput = mSpatializer->getOutput();
581 audio_io_handle_t newOutput;
582 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
583 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200584
Andy Hung79eacdb2023-11-30 19:34:24 -0800585 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200586 status_t status =
587 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100588 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
589 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200590 if (status == NO_ERROR && currentOutput == newOutput) {
591 return;
592 }
Eric Laurent15903592022-02-24 20:44:36 +0100593 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Andy Hung79eacdb2023-11-30 19:34:24 -0800594 mMutex.unlock();
Eric Laurent39095982021-08-24 18:29:27 +0200595 // It is OK to call detachOutput() is none is already attached.
596 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200597 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
598 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200599 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800600 mMutex.lock();
Eric Laurent39095982021-08-24 18:29:27 +0200601 if (status != NO_ERROR) {
602 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
603 }
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000604 } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
605 mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200606 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200607
Eric Laurent39095982021-08-24 18:29:27 +0200608 if (output != AUDIO_IO_HANDLE_NONE) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800609 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200610 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200611 }
612 }
613 }
614}
615
Eric Laurent11094172022-04-05 18:27:42 +0200616size_t AudioPolicyService::countActiveClientsOnOutput_l(
617 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100618 size_t count = 0;
619 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
620 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200621 if (client->io == output && client->active
622 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100623 count++;
624 }
625 }
626 return count;
627}
628
629void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
630 if (mSpatializer == nullptr) {
631 return;
632 }
633 mOutputCommandThread->updateActiveSpatializerTracksCommand();
634}
635
636void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
637{
Eric Laurent21270b62022-07-04 15:11:29 +0200638 if (mSpatializer == nullptr) {
639 return;
640 }
641 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200642 size_t activeClients;
643 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800644 audio_utils::lock_guard _l(mMutex);
Eric Laurent21270b62022-07-04 15:11:29 +0200645 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100646 }
Eric Laurent21270b62022-07-04 15:11:29 +0200647 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100648}
649
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800650status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
651 audio_patch_handle_t *handle,
652 int delayMs)
653{
654 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
655}
656
657status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
658 int delayMs)
659{
660 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
661}
662
Eric Laurente1715a42014-05-20 11:30:42 -0700663status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
664 int delayMs)
665{
666 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
667}
668
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800669AudioPolicyService::NotificationClient::NotificationClient(
670 const sp<AudioPolicyService>& service,
671 const sp<media::IAudioPolicyServiceClient>& client,
672 uid_t uid,
673 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800674 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100675 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700676{
677}
678
679AudioPolicyService::NotificationClient::~NotificationClient()
680{
681}
682
683void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
684{
685 sp<NotificationClient> keep(this);
686 sp<AudioPolicyService> service = mService.promote();
687 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800688 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700689 }
690}
691
692void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
693{
Eric Laurente8726fe2015-06-26 09:39:24 -0700694 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700695 mAudioPolicyServiceClient->onAudioPortListUpdate();
696 }
697}
698
699void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
700{
Eric Laurente8726fe2015-06-26 09:39:24 -0700701 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700702 mAudioPolicyServiceClient->onAudioPatchListUpdate();
703 }
704}
Eric Laurent57dae992011-07-24 13:36:09 -0700705
Pattydd807582021-11-04 21:01:03 +0800706void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100707 int flags)
708{
709 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
710 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
711 }
712}
713
714
Jean-Michel Trivide801052015-04-14 19:10:14 -0700715void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700716 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700717{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700718 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800719 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
720 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800721 }
722}
723
724void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800725 int event,
726 const record_client_info_t *clientInfo,
727 const audio_config_base_t *clientConfig,
728 std::vector<effect_descriptor_t> clientEffects,
729 const audio_config_base_t *deviceConfig,
730 std::vector<effect_descriptor_t> effects,
731 audio_patch_handle_t patchHandle,
732 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800733{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700734 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800735 status_t status = [&]() -> status_t {
736 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
737 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
738 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700739 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700740 legacy2aidl_audio_config_base_t_AudioConfigBase(
741 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800742 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
743 convertContainer<std::vector<media::EffectDescriptor>>(
744 clientEffects,
745 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700746 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700747 legacy2aidl_audio_config_base_t_AudioConfigBase(
748 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800749 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
750 convertContainer<std::vector<media::EffectDescriptor>>(
751 effects,
752 legacy2aidl_effect_descriptor_t_EffectDescriptor));
753 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
754 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700755 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
756 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800757 return aidl_utils::statusTFromBinderStatus(
758 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
759 clientInfoAidl,
760 clientConfigAidl,
761 clientEffectsAidl,
762 deviceConfigAidl,
763 effectsAidl,
764 patchHandleAidl,
765 sourceAidl));
766 }();
767 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700768 }
769}
770
Eric Laurente8726fe2015-06-26 09:39:24 -0700771void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
772{
773 mAudioPortCallbacksEnabled = enabled;
774}
775
François Gaffiecfe17322018-11-07 13:41:29 +0100776void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
777{
778 mAudioVolumeGroupCallbacksEnabled = enabled;
779}
Eric Laurente8726fe2015-06-26 09:39:24 -0700780
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700781void AudioPolicyService::NotificationClient::onRoutingUpdated()
782{
783 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
784 mAudioPolicyServiceClient->onRoutingUpdated();
785 }
786}
787
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000788void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
789{
790 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
791 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
792 }
793}
794
Mathias Agopian65ab4712010-07-14 17:59:35 -0700795void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700796 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700797 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700798}
799
Andy Hung79eacdb2023-11-30 19:34:24 -0800800static void dumpReleaseLock(audio_utils::mutex& mutex, bool locked)
801 RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000802{
803 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700804}
805
806status_t AudioPolicyService::dumpInternals(int fd)
807{
808 const size_t SIZE = 256;
809 char buffer[SIZE];
810 String8 result;
811
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000812 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800813 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000814 std::stringstream msg;
815 size_t i = 0;
816 for (auto usage : mSupportedSystemUsages) {
817 if (i++ != 0) msg << ", ";
818 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
819 msg << strUsage;
820 } else {
821 msg << usage << " (unknown)";
822 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800823 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000824 if (i == 0) {
825 msg << "None";
826 }
827 msg << std::endl;
828 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800829
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000830 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800831
832 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700833 return NO_ERROR;
834}
835
Eric Laurente8c8b432018-10-17 10:08:02 -0700836void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800837{
Andy Hung79eacdb2023-11-30 19:34:24 -0800838 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700839 updateUidStates_l();
840}
841
842void AudioPolicyService::updateUidStates_l()
843{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800844// Go over all active clients and allow capture (does not force silence) in the
845// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800846// The client is in the active assistant list
847// AND is TOP
848// AND an accessibility service is TOP
849// AND source is either VOICE_RECOGNITION OR HOTWORD
850// OR there is no active privacy sensitive capture or call
851// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
852// AND source is VOICE_RECOGNITION OR HOTWORD
853// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800854// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700855// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800856// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800857// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800858// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
859// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800860// OR The client is an accessibility service
861// AND Is on TOP
862// AND the source is VOICE_RECOGNITION or HOTWORD
863// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700864// AND there is no active privacy sensitive capture or call
865// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800866// AND is on TOP
867// AND the source is VOICE_RECOGNITION or HOTWORD
868// OR the client source is virtual (remote submix, call audio TX or RX...)
869// OR the client source is HOTWORD
870// AND is on TOP
871// OR all active clients are using HOTWORD source
872// AND no call is active
873// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
874// OR the client is the current InputMethodService
875// AND a RTT call is active AND the source is VOICE_RECOGNITION
Shunkai Yao7c868ca2024-05-07 01:08:11 +0000876// OR The client is an active communication owner
877// AND is on TOP or latest started
Evan Severson1f700cd2021-02-10 13:10:37 -0800878// OR Any client
879// AND The assistant is not on TOP
880// AND is on TOP or latest started
881// AND there is no active privacy sensitive capture or call
882// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800883
Eric Laurent4e947da2019-10-17 15:24:06 -0700884
Eric Laurent4eb58f12018-12-07 16:41:02 -0800885 sp<AudioRecordClient> topActive;
886 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800887 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700888 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800889 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700890
Eric Laurenta46bedb2018-12-07 18:01:26 -0800891 nsecs_t topStartNs = 0;
892 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800893 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800894 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800895 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800896 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
897 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800898 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800899 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700900 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800901 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
902 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700903 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700904 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700905 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800906
Michael Groovercfd28302018-12-11 19:16:46 -0800907 // if Sensor Privacy is enabled then all recordings should be silenced.
908 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
909 silenceAllRecordings_l();
910 return;
911 }
912
Eric Laurente8c8b432018-10-17 10:08:02 -0700913 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
914 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000915 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
916 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800917 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700918 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800919 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700920
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700921 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700922 // clients which app is in IDLE state are not eligible for top active or
923 // latest active
924 if (appState == APP_STATE_IDLE) {
925 continue;
926 }
927
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700928 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700929 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800930 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700931 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700932 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800933 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800934 bool isPrivacySensitive =
935 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700936
Eric Laurentc21d5692020-02-25 10:24:36 -0800937 if (appState == APP_STATE_TOP) {
938 if (isPrivacySensitive) {
939 if (current->startTimeNs > topSensitiveStartNs) {
940 topSensitiveActive = current;
941 topSensitiveStartNs = current->startTimeNs;
942 }
943 } else {
944 if (current->startTimeNs > topStartNs) {
945 topActive = current;
946 topStartNs = current->startTimeNs;
947 }
948 }
949 if (isAssistant) {
950 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800951 if (isActiveAssistant) {
952 useActiveAssistantList = true;
953 } else if (!useActiveAssistantList) {
954 if (current->startTimeNs > latestAssistantStartNs) {
955 latestActiveAssistant = current;
956 latestAssistantStartNs = current->startTimeNs;
957 }
958 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800959 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800960 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800961 // Clients capturing for HOTWORD are not considered
962 // for latest active to avoid masking regular clients started before
963 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
964 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
965 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700966 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
967 // is marked latest sensitive active even if another app qualifies.
968 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700969 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700970 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700971 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000972 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700973 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700974 latestSensitiveActiveOrComm = current;
975 latestSensitiveStartNs = current->startTimeNs;
976 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800977 }
978 isSensitiveActive = true;
979 } else {
980 if (current->startTimeNs > latestStartNs) {
981 latestActive = current;
982 latestStartNs = current->startTimeNs;
983 }
984 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800985 }
986 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000987 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
988 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700989 onlyHotwordActive = false;
990 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100991 if (currentUid == mPhoneStateOwnerUid &&
992 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700993 isPhoneStateOwnerActive = true;
994 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800995 }
996
Eric Laurent1ff16a72019-03-14 18:35:04 -0700997 // if no active client with UI on Top, consider latest active as top
998 if (topActive == nullptr) {
999 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -08001000 topStartNs = latestStartNs;
1001 }
1002 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -07001003 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -08001004 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -07001005 } else if (latestSensitiveActiveOrComm != nullptr) {
1006 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
1007 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001008 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +00001009 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001010 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -07001011 topSensitiveActive = latestSensitiveActiveOrComm;
1012 topSensitiveStartNs = latestSensitiveStartNs;
1013 }
Eric Laurentc21d5692020-02-25 10:24:36 -08001014 }
1015
1016 // If both privacy sensitive and regular capture are active:
1017 // if the regular capture is privileged
1018 // allow concurrency
1019 // else
1020 // favor the privacy sensitive case
1021 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001022 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001023 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001024 }
1025
1026 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1027 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001028 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001029 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001030 if (!current->active) {
1031 continue;
1032 }
1033
Eric Laurent4eb58f12018-12-07 16:41:02 -08001034 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001035 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001036 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001037 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001038 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001039 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1040 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001041
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001042 // TODO: b/339112720
1043 // Refine this logic when we have the correct phone state owner UID. The current issue is
1044 // when a VOIP APP use Telecom API to manage calls, the mPhoneStateOwnerUid is AID_SYSTEM
1045 // instead of the actual VOIP APP UID, so isPhoneStateOwnerActive here is not accurate.
1046 const bool canCaptureIfInCallOrCommunication = [&](const auto& recordClient) REQUIRES(
1047 mMutex) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001048 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001049 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001050 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001051 bool canCaptureCommunication = recordClient->canCaptureOutput
1052 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001053 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001054 return !(isInCall && !canCaptureCall)
1055 && !(isInCommunication && !canCaptureCommunication);
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001056 }(current);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001057
1058 // By default allow capture if:
1059 // The assistant is not on TOP
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001060 // AND is on TOP or latest started
1061 // AND there is no active privacy sensitive capture or call
Eric Laurent1ff16a72019-03-14 18:35:04 -07001062 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001063 // The assistant is on TOP
1064 // AND is ongoing communication owner
1065 // AND is on TOP or latest started
1066 const bool allowSensitiveCapture =
Eric Laurent4ab18412022-11-07 16:25:32 +01001067 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001068 bool allowCapture = false;
1069 if (!isAssistantOnTop) {
1070 allowCapture = (isTopOrLatestActive || isTopOrLatestSensitive) &&
1071 allowSensitiveCapture && canCaptureIfInCallOrCommunication;
1072 } else {
1073 allowCapture = isInCommunication && isTopOrLatestSensitive &&
1074 canCaptureIfInCallOrCommunication;
1075 }
Eric Laurent2dc962b2019-03-01 08:25:25 -08001076
Eric Laurented726cc2021-07-01 14:26:41 +02001077 if (!current->hasOp()) {
1078 // Never allow capture if app op is denied
1079 allowCapture = false;
1080 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001081 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1082 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001083 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001084 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001085 // Active assistant list is not being used
1086 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001087 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001088 // OR there is no active privacy sensitive capture or call
1089 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1090 // AND is latest TOP assistant AND
1091 // uses VOICE_RECOGNITION OR uses HOTWORD
1092 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001093 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001094 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001095 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001096 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001097 } else if (allowSensitiveCapture
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001098 && canCaptureIfInCallOrCommunication) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001099 if (isTopOrLatestAssistant
1100 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1101 || source == AUDIO_SOURCE_HOTWORD)) {
1102 allowCapture = true;
1103 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1104 allowCapture = true;
1105 }
1106 }
1107 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1108 // For assistant on active list and on top allow capture if:
1109 // An accessibility service is on TOP
1110 // AND the source is VOICE_RECOGNITION or HOTWORD
1111 // OR there is no active privacy sensitive capture or call
1112 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1113 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1114 if (isA11yOnTop) {
1115 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1116 allowCapture = true;
1117 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001118 } else if (allowSensitiveCapture
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001119 && canCaptureIfInCallOrCommunication) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001120 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1121 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001122 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001123 }
1124 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001125 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001126 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001127 // The assistant is not on TOP
1128 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001129 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001130 // OR
1131 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1132 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001133 && allowSensitiveCapture
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001134 && canCaptureIfInCallOrCommunication) {
Eric Laurent47670c92019-08-28 16:59:05 -07001135 allowCapture = true;
1136 }
Eric Laurent589171c2019-07-25 18:04:29 -07001137 if (isA11yOnTop) {
1138 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1139 allowCapture = true;
1140 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001141 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001142 } else if (source == AUDIO_SOURCE_HOTWORD) {
1143 // For HOTWORD source allow capture when not on TOP if:
1144 // All active clients are using HOTWORD source
1145 // AND no call is active
1146 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001147 if (onlyHotwordActive
Shunkai Yao7c868ca2024-05-07 01:08:11 +00001148 && canCaptureIfInCallOrCommunication) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001149 allowCapture = true;
1150 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001151 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001152 // For current InputMethodService allow capture if:
1153 // A RTT call is active AND the source is VOICE_RECOGNITION
1154 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1155 allowCapture = true;
1156 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001157 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001158 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001159 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001160 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001161 }
1162}
1163
Michael Groovercfd28302018-12-11 19:16:46 -08001164void AudioPolicyService::silenceAllRecordings_l() {
1165 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1166 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001167 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001168 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001169 }
Michael Groovercfd28302018-12-11 19:16:46 -08001170 }
1171}
1172
Eric Laurente8c8b432018-10-17 10:08:02 -07001173/* static */
1174app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001175
1176 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001177 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001178 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1179 // include persistent services
1180 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001181 }
1182 return APP_STATE_FOREGROUND;
1183}
1184
Eric Laurent4eb58f12018-12-07 16:41:02 -08001185/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001186bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001187{
1188 switch (source) {
1189 case AUDIO_SOURCE_VOICE_UPLINK:
1190 case AUDIO_SOURCE_VOICE_DOWNLINK:
1191 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001192 case AUDIO_SOURCE_REMOTE_SUBMIX:
1193 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001194 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001195 return true;
1196 default:
1197 break;
1198 }
1199 return false;
1200}
1201
Eric Laurent8c7ef892021-06-10 13:32:16 +02001202void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001203{
1204 AutoCallerClear acc;
1205
1206 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001207 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001208 }
1209 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1210 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001211 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001212 if (client->silenced != silenced) {
1213 if (client->active) {
1214 if (silenced) {
Marvin Raminb03b49f2024-04-04 16:25:31 +02001215 finishRecording(client->attributionSource, client->virtualDeviceId,
1216 client->attributes.source);
Eric Laurent8c7ef892021-06-10 13:32:16 +02001217 } else {
1218 std::stringstream msg;
1219 msg << "Audio recording un-silenced on session " << client->session;
Marvin Raminb03b49f2024-04-04 16:25:31 +02001220 if (!startRecording(client->attributionSource, client->virtualDeviceId,
1221 String16(msg.str().c_str()), client->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001222 silenced = true;
1223 }
1224 }
1225 }
1226 af->setRecordSilenced(client->portId, silenced);
1227 client->silenced = silenced;
1228 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001229 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001230}
1231
Glenn Kasten0f11b512014-01-31 16:18:54 -08001232status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Andy Hung79eacdb2023-11-30 19:34:24 -08001233NO_THREAD_SAFETY_ANALYSIS // update for trylock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001234{
Glenn Kasten44deb052012-02-05 18:09:08 -08001235 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001236 dumpPermissionDenial(fd);
1237 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001238 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001239 if (!locked) {
1240 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001241 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001242 }
1243
1244 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001245
1246 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001247 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001248 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001249 mAudioCommandThread->dump(fd);
1250 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001251
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001252 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001253 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001254 if (mOutputCommandThread != 0) {
1255 mOutputCommandThread->dump(fd);
1256 }
1257
Eric Laurentdce54a12014-03-10 12:19:46 -07001258 if (mAudioPolicyManager) {
1259 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001260 } else {
1261 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001262 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001263 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001264
Kevin Rocard8be94972019-02-22 13:26:25 -08001265 mPackageManager.dump(fd);
1266
Andy Hung79eacdb2023-11-30 19:34:24 -08001267 dumpReleaseLock(mMutex, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001268
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001269 if (mSpatializer != nullptr) {
1270 std::string dumpString = mSpatializer->toString(1 /* level */);
1271 write(fd, dumpString.c_str(), dumpString.size());
1272 } else {
1273 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1274 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1275 }
1276
Andy Hungc747c532022-03-07 21:41:14 -08001277 {
1278 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1279 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1280 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1281 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001282 }
1283 return NO_ERROR;
1284}
1285
1286status_t AudioPolicyService::dumpPermissionDenial(int fd)
1287{
1288 const size_t SIZE = 256;
1289 char buffer[SIZE];
1290 String8 result;
1291 snprintf(buffer, SIZE, "Permission Denial: "
1292 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1293 IPCThreadState::self()->getCallingPid(),
1294 IPCThreadState::self()->getCallingUid());
1295 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001296 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001297 return NO_ERROR;
1298}
1299
1300status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001301 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001302 // make sure transactions reserved to AudioFlinger do not come from other processes
1303 switch (code) {
1304 case TRANSACTION_startOutput:
1305 case TRANSACTION_stopOutput:
1306 case TRANSACTION_releaseOutput:
1307 case TRANSACTION_getInputForAttr:
1308 case TRANSACTION_startInput:
1309 case TRANSACTION_stopInput:
1310 case TRANSACTION_releaseInput:
1311 case TRANSACTION_getOutputForEffect:
1312 case TRANSACTION_registerEffect:
1313 case TRANSACTION_unregisterEffect:
1314 case TRANSACTION_setEffectEnabled:
1315 case TRANSACTION_getStrategyForStream:
1316 case TRANSACTION_getOutputForAttr:
1317 case TRANSACTION_moveEffectsToIo:
1318 ALOGW("%s: transaction %d received from PID %d",
1319 __func__, code, IPCThreadState::self()->getCallingPid());
1320 return INVALID_OPERATION;
1321 default:
1322 break;
1323 }
1324
1325 // make sure the following transactions come from system components
1326 switch (code) {
1327 case TRANSACTION_setDeviceConnectionState:
1328 case TRANSACTION_handleDeviceConfigChange:
1329 case TRANSACTION_setPhoneState:
1330//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1331// case TRANSACTION_setForceUse:
Vlad Popa87e0e582024-05-20 18:49:20 -07001332 case TRANSACTION_setDeviceAbsoluteVolumeEnabled:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001333 case TRANSACTION_initStreamVolume:
1334 case TRANSACTION_setStreamVolumeIndex:
1335 case TRANSACTION_setVolumeIndexForAttributes:
1336 case TRANSACTION_getStreamVolumeIndex:
1337 case TRANSACTION_getVolumeIndexForAttributes:
1338 case TRANSACTION_getMinVolumeIndexForAttributes:
1339 case TRANSACTION_getMaxVolumeIndexForAttributes:
1340 case TRANSACTION_isStreamActive:
1341 case TRANSACTION_isStreamActiveRemotely:
1342 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001343 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001344 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001345 case TRANSACTION_setMasterMono:
1346 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001347 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001348 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001349 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001350 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001351 case TRANSACTION_setA11yServicesUids:
1352 case TRANSACTION_setUidDeviceAffinities:
1353 case TRANSACTION_removeUidDeviceAffinities:
1354 case TRANSACTION_setUserIdDeviceAffinities:
1355 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001356 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001357 case TRANSACTION_listAudioVolumeGroups:
1358 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1359 case TRANSACTION_acquireSoundTriggerSession:
1360 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001361 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001362 case TRANSACTION_setRttEnabled:
1363 case TRANSACTION_isCallScreenModeSupported:
1364 case TRANSACTION_setDevicesRoleForStrategy:
1365 case TRANSACTION_setSupportedSystemUsages:
1366 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001367 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001368 case TRANSACTION_getDevicesForRoleAndStrategy:
1369 case TRANSACTION_getDevicesForAttributes:
1370 case TRANSACTION_setAllowedCapturePolicy:
1371 case TRANSACTION_onNewAudioModulesAvailable:
1372 case TRANSACTION_setCurrentImeUid:
1373 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1374 case TRANSACTION_setDevicesRoleForCapturePreset:
1375 case TRANSACTION_addDevicesRoleForCapturePreset:
1376 case TRANSACTION_removeDevicesRoleForCapturePreset:
1377 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001378 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001379 case TRANSACTION_getSpatializer:
1380 case TRANSACTION_setPreferredMixerAttributes:
Marvin Raminbdefaf02023-11-01 09:10:32 +01001381 case TRANSACTION_clearPreferredMixerAttributes:
1382 case TRANSACTION_getRegisteredPolicyMixes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001383 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1384 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1385 __func__, code, IPCThreadState::self()->getCallingPid(),
1386 IPCThreadState::self()->getCallingUid());
1387 return INVALID_OPERATION;
1388 }
1389 } break;
1390 default:
1391 break;
1392 }
1393
Atneya Nair9f91a5e2024-05-09 16:25:05 -07001394 switch (code) {
1395 case TRANSACTION_getPermissionController: {
1396 if (!isAudioServerOrSystemServerUid(IPCThreadState::self()->getCallingUid())) {
1397 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1398 __func__, code, IPCThreadState::self()->getCallingPid(),
1399 IPCThreadState::self()->getCallingUid());
1400 return INVALID_OPERATION;
1401 }
1402 }
1403 }
1404
Andy Hungc747c532022-03-07 21:41:14 -08001405 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1406 mediautils::TimeCheck check(
1407 std::string("IAudioPolicyService::").append(methodName),
1408 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1409 if (timeout) {
1410 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1411 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1412 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1413 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1414 .record();
1415 } else {
1416 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1417 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001418 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1419 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1420 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001421
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001422 switch (code) {
1423 case SHELL_COMMAND_TRANSACTION: {
1424 int in = data.readFileDescriptor();
1425 int out = data.readFileDescriptor();
1426 int err = data.readFileDescriptor();
1427 int argc = data.readInt32();
1428 Vector<String16> args;
1429 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1430 args.add(data.readString16());
1431 }
1432 sp<IBinder> unusedCallback;
1433 sp<IResultReceiver> resultReceiver;
1434 status_t status;
1435 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1436 return status;
1437 }
1438 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1439 return status;
1440 }
1441 status = shellCommand(in, out, err, args);
1442 if (resultReceiver != nullptr) {
1443 resultReceiver->send(status);
1444 }
1445 return NO_ERROR;
1446 }
1447 }
1448
Mathias Agopian65ab4712010-07-14 17:59:35 -07001449 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1450}
1451
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001452// ------------------- Shell command implementation -------------------
1453
1454// NOTE: This is a remote API - make sure all args are validated
1455status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1456 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1457 return PERMISSION_DENIED;
1458 }
1459 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1460 return BAD_VALUE;
1461 }
Atneya Nair56a436a2024-04-03 11:11:58 -07001462 if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
Eric Laurent269acb42021-04-23 16:53:22 +02001463 purgePermissionCache();
1464 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001465 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001466 return BAD_VALUE;
1467}
1468
Eric Laurent0d13fea2022-11-04 17:12:08 +01001469status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1470 const audio_config_base_t& config,
1471 const audio_output_flags_t flags) {
1472 return mUsecaseValidator->registerStream(output, config, flags);
1473}
1474
1475status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1476 return mUsecaseValidator->unregisterStream(output);
1477}
1478
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001479// ----------- AudioPolicyService::UidPolicy implementation ----------
1480
1481void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001482 status_t res = mAm.linkToDeath(this);
1483 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001484 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001485 | ActivityManager::UID_OBSERVER_ACTIVE
1486 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001487 ActivityManager::PROCESS_STATE_UNKNOWN,
1488 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001489 if (!res) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001490 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001491 mObserverRegistered = true;
1492 } else {
1493 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001494
Steven Moreland2f348142019-07-02 15:59:07 -07001495 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001496 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001497}
1498
1499void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001500 mAm.unlinkToDeath(this);
1501 mAm.unregisterUidObserver(this);
Andy Hung79eacdb2023-11-30 19:34:24 -08001502 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001503 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001504}
1505
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001506void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001507 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001508 mCachedUids.clear();
1509 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001510}
1511
Eric Laurente8c8b432018-10-17 10:08:02 -07001512void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001513 bool needToReregister = false;
1514 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001515 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001516 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001517 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001518 if (needToReregister) {
1519 // Looks like ActivityManager has died previously, attempt to re-register.
1520 registerSelf();
1521 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001522}
1523
1524bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1525 if (isServiceUid(uid)) return true;
1526 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001527 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001528 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001529 // In an absense of the ActivityManager, assume everything to be active.
1530 if (!mObserverRegistered) return true;
1531 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001532 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001533 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001534 }
1535 }
1536 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001537 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001538 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001539 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001540 mCachedUids.insert(std::pair<uid_t,
1541 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1542 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001543 }
1544 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001545}
1546
Eric Laurente8c8b432018-10-17 10:08:02 -07001547int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1548 if (isServiceUid(uid)) {
1549 return ActivityManager::PROCESS_STATE_TOP;
1550 }
1551 checkRegistered();
1552 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001553 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001554 // In an absense of the ActivityManager, assume everything to be active.
1555 if (!mObserverRegistered) {
1556 return ActivityManager::PROCESS_STATE_TOP;
1557 }
1558 auto cacheIter = mCachedUids.find(uid);
1559 if (cacheIter != mCachedUids.end()) {
1560 if (cacheIter->second.first) {
1561 return cacheIter->second.second;
1562 } else {
1563 return ActivityManager::PROCESS_STATE_UNKNOWN;
1564 }
1565 }
1566 }
1567 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001568 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001569 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1570 if (active) {
1571 state = am.getUidProcessState(uid, String16("audioserver"));
1572 }
1573 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001574 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001575 mCachedUids.insert(std::pair<uid_t,
1576 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1577 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001578
Eric Laurente8c8b432018-10-17 10:08:02 -07001579 return state;
1580}
1581
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001582void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001583 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001584}
1585
1586void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001587 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001588}
1589
1590void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001591 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001592}
1593
Eric Laurente8c8b432018-10-17 10:08:02 -07001594void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1595 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001596 int64_t procStateSeq __unused,
1597 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001598 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1599 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001600 }
1601}
1602
Austin Borgerdddb7552023-03-30 17:53:01 -07001603void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001604}
1605
Eric Laurente8c8b432018-10-17 10:08:02 -07001606void AudioPolicyService::UidPolicy::notifyService() {
1607 sp<AudioPolicyService> service = mService.promote();
1608 if (service != nullptr) {
1609 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001610 }
1611}
1612
Eric Laurente8c8b432018-10-17 10:08:02 -07001613void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1614 std::pair<bool, int>> *uids,
1615 uid_t uid,
1616 bool active,
1617 int state,
1618 bool insert) {
1619 if (isServiceUid(uid)) {
1620 return;
1621 }
1622 bool wasActive = isUidActive(uid);
1623 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001624 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001625 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001626 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001627 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001628 if (wasActive != isUidActive(uid) || state != previousState) {
1629 notifyService();
1630 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001631}
1632
Eric Laurente8c8b432018-10-17 10:08:02 -07001633void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1634 std::pair<bool, int>> *uids,
1635 uid_t uid,
1636 bool active,
1637 int state,
1638 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001639 auto it = uids->find(uid);
1640 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001641 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001642 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1643 it->second.first = active;
1644 }
1645 if (it->second.first) {
1646 it->second.second = state;
1647 } else {
1648 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1649 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001650 } else {
1651 uids->erase(it);
1652 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001653 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1654 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1655 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001656 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001657}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001658
Eric Laurent4eb58f12018-12-07 16:41:02 -08001659bool AudioPolicyService::UidPolicy::isA11yOnTop() {
Andy Hung79eacdb2023-11-30 19:34:24 -08001660 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001661 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001662 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001663 continue;
1664 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001665 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1666 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001667 return true;
1668 }
1669 }
1670 return false;
1671}
1672
Eric Laurentb78763e2018-10-17 10:08:02 -07001673bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1674{
1675 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1676 return it != mA11yUids.end();
1677}
1678
Oscar Azucena829d90d2022-01-28 17:17:56 -08001679void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1680 mAssistantUids.clear();
1681 mAssistantUids = uids;
1682}
1683
1684bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1685{
1686 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1687 return it != mAssistantUids.end();
1688}
1689
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001690void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1691 mActiveAssistantUids = activeUids;
1692}
1693
1694bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1695{
1696 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1697 mActiveAssistantUids.end(), uid);
1698 return it != mActiveAssistantUids.end();
1699}
1700
Oscar Azucena829d90d2022-01-28 17:17:56 -08001701void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1702 const size_t SIZE = 256;
1703 char buffer[SIZE];
1704 String8 result;
1705 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1706 snprintf(buffer, SIZE, "\t%s: \n", title);
1707 result.append(buffer);
1708 int counter = 0;
1709 if (uids.empty()) {
1710 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1711 result.append(buffer);
1712 return;
1713 }
1714 for (const auto &uid : uids) {
1715 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1716 result.append(buffer);
1717 }
1718 };
1719
1720 snprintf(buffer, SIZE, "UID Policy:\n");
1721 result.append(buffer);
1722 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1723 result.append(buffer);
1724
1725 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001726 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001727
1728 appendUidsToResult("Accessibility UIDs", mA11yUids);
1729
1730 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1731 result.append(buffer);
1732
1733 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1734 result.append(buffer);
1735
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001736 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001737}
1738
Michael Groovercfd28302018-12-11 19:16:46 -08001739// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1740void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1741 SensorPrivacyManager spm;
1742 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1743 spm.addSensorPrivacyListener(this);
1744}
1745
1746void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1747 SensorPrivacyManager spm;
1748 spm.removeSensorPrivacyListener(this);
1749}
1750
1751bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1752 return mSensorPrivacyEnabled;
1753}
1754
Evan Seversond8dc6832022-01-27 10:47:03 -08001755binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1756 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001757 mSensorPrivacyEnabled = enabled;
1758 sp<AudioPolicyService> service = mService.promote();
1759 if (service != nullptr) {
1760 service->updateUidStates();
1761 }
1762 return binder::Status::ok();
1763}
1764
Mathias Agopian65ab4712010-07-14 17:59:35 -07001765// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1766
Eric Laurentbfb1b832013-01-07 09:53:42 -08001767AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1768 const wp<AudioPolicyService>& service)
1769 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001770{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001771}
1772
1773
1774AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1775{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001776 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001777 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001778 }
1779 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001780}
1781
1782void AudioPolicyService::AudioCommandThread::onFirstRef()
1783{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001784 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001785}
1786
1787bool AudioPolicyService::AudioCommandThread::threadLoop()
1788{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001789 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001790
Andy Hung79eacdb2023-11-30 19:34:24 -08001791 audio_utils::unique_lock ul(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001792 while (!exitPending())
1793 {
Eric Laurent59a89232014-06-08 14:14:17 -07001794 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001795 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001796 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001797 nsecs_t curTime = systemTime();
1798 // commands are sorted by increasing time stamp: execute them from index 0 and up
1799 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001800 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001801 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001802 if (mAudioCommands.isEmpty()) {
1803 ++numTimesBecameEmpty;
1804 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001805 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001806
1807 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001808 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001809 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001810 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001811 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001812 ul.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001813 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1814 data->mVolume,
1815 data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001816 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001817 }break;
1818 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001819 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001820 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001821 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001822 ul.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001823 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hung79eacdb2023-11-30 19:34:24 -08001824 ul.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001825 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001826 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001827 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001828 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001829 data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001830 ul.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001831 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001832 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001833 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001834 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001835 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001836 ALOGV("AudioCommandThread() processing stop output portId %d",
1837 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001838 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001839 if (svc == 0) {
1840 break;
1841 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001842 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001843 svc->doStopOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001844 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001845 }break;
1846 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001847 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001848 ALOGV("AudioCommandThread() processing release output portId %d",
1849 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001850 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001851 if (svc == 0) {
1852 break;
1853 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001854 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001855 svc->doReleaseOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001856 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001857 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001858 case CREATE_AUDIO_PATCH: {
1859 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1860 ALOGV("AudioCommandThread() processing create audio patch");
1861 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1862 if (af == 0) {
1863 command->mStatus = PERMISSION_DENIED;
1864 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001865 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001866 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001867 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001868 }
1869 } break;
1870 case RELEASE_AUDIO_PATCH: {
1871 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1872 ALOGV("AudioCommandThread() processing release audio patch");
1873 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1874 if (af == 0) {
1875 command->mStatus = PERMISSION_DENIED;
1876 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001877 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001878 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001879 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001880 }
1881 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001882 case UPDATE_AUDIOPORT_LIST: {
1883 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001884 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001885 if (svc == 0) {
1886 break;
1887 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001888 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001889 svc->doOnAudioPortListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001890 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001891 }break;
1892 case UPDATE_AUDIOPATCH_LIST: {
1893 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07001894 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001895 if (svc == 0) {
1896 break;
1897 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001898 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001899 svc->doOnAudioPatchListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001900 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001901 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01001902 case CHANGED_AUDIOVOLUMEGROUP: {
1903 AudioVolumeGroupData *data =
1904 static_cast<AudioVolumeGroupData *>(command->mParam.get());
1905 ALOGV("AudioCommandThread() processing update audio volume group");
1906 svc = mService.promote();
1907 if (svc == 0) {
1908 break;
1909 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001910 ul.unlock();
François Gaffiecfe17322018-11-07 13:41:29 +01001911 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
Andy Hung79eacdb2023-11-30 19:34:24 -08001912 ul.lock();
François Gaffiecfe17322018-11-07 13:41:29 +01001913 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07001914 case SET_AUDIOPORT_CONFIG: {
1915 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
1916 ALOGV("AudioCommandThread() processing set port config");
1917 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1918 if (af == 0) {
1919 command->mStatus = PERMISSION_DENIED;
1920 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001921 ul.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07001922 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hung79eacdb2023-11-30 19:34:24 -08001923 ul.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07001924 }
1925 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07001926 case DYN_POLICY_MIX_STATE_UPDATE: {
1927 DynPolicyMixStateUpdateData *data =
1928 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001929 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001930 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07001931 svc = mService.promote();
1932 if (svc == 0) {
1933 break;
1934 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001935 ul.unlock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001936 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
Andy Hung79eacdb2023-11-30 19:34:24 -08001937 ul.lock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001938 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001939 case RECORDING_CONFIGURATION_UPDATE: {
1940 RecordingConfigurationUpdateData *data =
1941 (RecordingConfigurationUpdateData *)command->mParam.get();
1942 ALOGV("AudioCommandThread() processing recording configuration update");
1943 svc = mService.promote();
1944 if (svc == 0) {
1945 break;
1946 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001947 ul.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001948 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08001949 &data->mClientConfig, data->mClientEffects,
1950 &data->mDeviceConfig, data->mEffects,
1951 data->mPatchHandle, data->mSource);
Andy Hung79eacdb2023-11-30 19:34:24 -08001952 ul.lock();
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001953 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001954 case SET_EFFECT_SUSPENDED: {
1955 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
1956 ALOGV("AudioCommandThread() processing set effect suspended");
1957 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1958 if (af != 0) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001959 ul.unlock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001960 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
Andy Hung79eacdb2023-11-30 19:34:24 -08001961 ul.lock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001962 }
1963 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001964 case AUDIO_MODULES_UPDATE: {
1965 ALOGV("AudioCommandThread() processing audio modules update");
1966 svc = mService.promote();
1967 if (svc == 0) {
1968 break;
1969 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001970 ul.unlock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001971 svc->doOnNewAudioModulesAvailable();
Andy Hung79eacdb2023-11-30 19:34:24 -08001972 ul.lock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001973 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001974 case ROUTING_UPDATED: {
1975 ALOGV("AudioCommandThread() processing routing update");
1976 svc = mService.promote();
1977 if (svc == 0) {
1978 break;
1979 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001980 ul.unlock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001981 svc->doOnRoutingUpdated();
Andy Hung79eacdb2023-11-30 19:34:24 -08001982 ul.lock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001983 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001984
Eric Laurented726cc2021-07-01 14:26:41 +02001985 case UPDATE_UID_STATES: {
1986 ALOGV("AudioCommandThread() processing updateUID states");
1987 svc = mService.promote();
1988 if (svc == 0) {
1989 break;
1990 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001991 ul.unlock();
Eric Laurented726cc2021-07-01 14:26:41 +02001992 svc->updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -08001993 ul.lock();
Eric Laurented726cc2021-07-01 14:26:41 +02001994 } break;
1995
Eric Laurent15903592022-02-24 20:44:36 +01001996 case CHECK_SPATIALIZER_OUTPUT: {
1997 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02001998 svc = mService.promote();
1999 if (svc == 0) {
2000 break;
2001 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002002 ul.unlock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002003 svc->doOnCheckSpatializer();
Andy Hung79eacdb2023-11-30 19:34:24 -08002004 ul.lock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02002005 } break;
2006
Eric Laurent15903592022-02-24 20:44:36 +01002007 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
2008 ALOGV("AudioCommandThread() processing update spatializer tracks");
2009 svc = mService.promote();
2010 if (svc == 0) {
2011 break;
2012 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002013 ul.unlock();
Eric Laurent15903592022-02-24 20:44:36 +01002014 svc->doOnUpdateActiveSpatializerTracks();
Andy Hung79eacdb2023-11-30 19:34:24 -08002015 ul.lock();
Eric Laurent15903592022-02-24 20:44:36 +01002016 } break;
2017
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002018 case VOL_RANGE_INIT_REQUEST: {
2019 ALOGV("AudioCommandThread() processing volume range init request");
2020 svc = mService.promote();
2021 if (svc == 0) {
2022 break;
2023 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002024 ul.unlock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002025 svc->doOnVolumeRangeInitRequest();
Andy Hung79eacdb2023-11-30 19:34:24 -08002026 ul.lock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002027 } break;
2028
Mathias Agopian65ab4712010-07-14 17:59:35 -07002029 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002030 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002031 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002032 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002033 audio_utils::lock_guard _l(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002034 if (command->mWaitStatus) {
2035 command->mWaitStatus = false;
Andy Hung79eacdb2023-11-30 19:34:24 -08002036 command->mCond.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002037 }
2038 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002039 waitTime = -1;
Andy Hung79eacdb2023-11-30 19:34:24 -08002040 // release ul before releasing strong reference on the service as
Zach Janga754b4f2015-10-27 01:29:34 +00002041 // AudioPolicyService destructor calls AudioCommandThread::exit() which
Andy Hung79eacdb2023-11-30 19:34:24 -08002042 // acquires ul.
2043 ul.unlock();
Zach Janga754b4f2015-10-27 01:29:34 +00002044 svc.clear();
Andy Hung79eacdb2023-11-30 19:34:24 -08002045 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002046 } else {
2047 waitTime = mAudioCommands[0]->mTime - curTime;
2048 break;
2049 }
2050 }
Zach Janga754b4f2015-10-27 01:29:34 +00002051
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002052 // release delayed commands wake lock as many times as we made the queue is
2053 // empty during popping.
2054 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002055 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002056 }
2057
2058 // At this stage we have either an empty command queue or the first command in the queue
2059 // has a finite delay. So unless we are exiting it is safe to wait.
2060 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002061 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002062 if (waitTime == -1) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002063 mWaitWorkCV.wait(ul);
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002064 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002065 // discard return value.
2066 mWaitWorkCV.wait_for(ul, std::chrono::nanoseconds(waitTime));
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002067 }
Eric Laurent59a89232014-06-08 14:14:17 -07002068 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002069 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002070 // release delayed commands wake lock before quitting
2071 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002072 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002073 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002074 return false;
2075}
2076
2077status_t AudioPolicyService::AudioCommandThread::dump(int fd)
Andy Hung79eacdb2023-11-30 19:34:24 -08002078NO_THREAD_SAFETY_ANALYSIS // trylock
Mathias Agopian65ab4712010-07-14 17:59:35 -07002079{
2080 const size_t SIZE = 256;
2081 char buffer[SIZE];
2082 String8 result;
2083
Andy Hung79eacdb2023-11-30 19:34:24 -08002084 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002085 if (!locked) {
2086 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002087 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002088 }
2089
2090 snprintf(buffer, SIZE, "- Commands:\n");
2091 result = String8(buffer);
2092 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002093 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002094 mAudioCommands[i]->dump(buffer, SIZE);
2095 result.append(buffer);
2096 }
2097 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002098 if (mLastCommand != 0) {
2099 mLastCommand->dump(buffer, SIZE);
2100 result.append(buffer);
2101 } else {
2102 result.append(" none\n");
2103 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002104
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002105 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002106
Andy Hung79eacdb2023-11-30 19:34:24 -08002107 dumpReleaseLock(mMutex, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002108
2109 return NO_ERROR;
2110}
2111
Glenn Kastenfff6d712012-01-12 16:38:12 -08002112status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002113 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002114 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002115 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002116{
Eric Laurent0ede8922014-05-09 18:04:42 -07002117 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002118 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002119 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002120 data->mStream = stream;
2121 data->mVolume = volume;
2122 data->mIO = output;
2123 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002124 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002125 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002126 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002127 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002128}
2129
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002130status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002131 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002132 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002133{
Eric Laurent0ede8922014-05-09 18:04:42 -07002134 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002135 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002136 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002137 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002138 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002139 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002140 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002141 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002142 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002143 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002144}
2145
2146status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2147{
Eric Laurent0ede8922014-05-09 18:04:42 -07002148 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002149 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002150 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002151 data->mVolume = volume;
2152 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002153 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002154 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002155 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002156}
2157
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002158void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2159 audio_session_t sessionId,
2160 bool suspended)
2161{
2162 sp<AudioCommand> command = new AudioCommand();
2163 command->mCommand = SET_EFFECT_SUSPENDED;
2164 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2165 data->mEffectId = effectId;
2166 data->mSessionId = sessionId;
2167 data->mSuspended = suspended;
2168 command->mParam = data;
2169 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2170 effectId, sessionId, suspended);
2171 sendCommand(command);
2172}
2173
2174
Eric Laurentd7fe0862018-07-14 16:48:01 -07002175void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002176{
Eric Laurent0ede8922014-05-09 18:04:42 -07002177 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002178 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002179 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002180 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002181 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002182 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002183 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002184}
2185
Eric Laurentd7fe0862018-07-14 16:48:01 -07002186void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002187{
Eric Laurent0ede8922014-05-09 18:04:42 -07002188 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002189 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002190 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002191 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002192 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002193 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002194 sendCommand(command);
2195}
2196
Eric Laurent951f4552014-05-20 10:48:17 -07002197status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2198 const struct audio_patch *patch,
2199 audio_patch_handle_t *handle,
2200 int delayMs)
2201{
2202 status_t status = NO_ERROR;
2203
2204 sp<AudioCommand> command = new AudioCommand();
2205 command->mCommand = CREATE_AUDIO_PATCH;
2206 CreateAudioPatchData *data = new CreateAudioPatchData();
2207 data->mPatch = *patch;
2208 data->mHandle = *handle;
2209 command->mParam = data;
2210 command->mWaitStatus = true;
2211 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2212 status = sendCommand(command, delayMs);
2213 if (status == NO_ERROR) {
2214 *handle = data->mHandle;
2215 }
2216 return status;
2217}
2218
2219status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2220 int delayMs)
2221{
2222 sp<AudioCommand> command = new AudioCommand();
2223 command->mCommand = RELEASE_AUDIO_PATCH;
2224 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2225 data->mHandle = handle;
2226 command->mParam = data;
2227 command->mWaitStatus = true;
2228 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2229 return sendCommand(command, delayMs);
2230}
2231
Eric Laurentb52c1522014-05-20 11:27:36 -07002232void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2233{
2234 sp<AudioCommand> command = new AudioCommand();
2235 command->mCommand = UPDATE_AUDIOPORT_LIST;
2236 ALOGV("AudioCommandThread() adding update audio port list");
2237 sendCommand(command);
2238}
2239
Eric Laurented726cc2021-07-01 14:26:41 +02002240void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2241{
2242 sp<AudioCommand> command = new AudioCommand();
2243 command->mCommand = UPDATE_UID_STATES;
2244 ALOGV("AudioCommandThread() adding update UID states");
2245 sendCommand(command);
2246}
2247
Eric Laurentb52c1522014-05-20 11:27:36 -07002248void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2249{
2250 sp<AudioCommand>command = new AudioCommand();
2251 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2252 ALOGV("AudioCommandThread() adding update audio patch list");
2253 sendCommand(command);
2254}
2255
François Gaffiecfe17322018-11-07 13:41:29 +01002256void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2257 int flags)
2258{
2259 sp<AudioCommand>command = new AudioCommand();
2260 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2261 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2262 data->mGroup = group;
2263 data->mFlags = flags;
2264 command->mParam = data;
2265 ALOGV("AudioCommandThread() adding audio volume group changed");
2266 sendCommand(command);
2267}
2268
Eric Laurente1715a42014-05-20 11:30:42 -07002269status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2270 const struct audio_port_config *config, int delayMs)
2271{
2272 sp<AudioCommand> command = new AudioCommand();
2273 command->mCommand = SET_AUDIOPORT_CONFIG;
2274 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2275 data->mConfig = *config;
2276 command->mParam = data;
2277 command->mWaitStatus = true;
2278 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2279 return sendCommand(command, delayMs);
2280}
2281
Jean-Michel Trivide801052015-04-14 19:10:14 -07002282void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002283 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002284{
2285 sp<AudioCommand> command = new AudioCommand();
2286 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2287 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2288 data->mRegId = regId;
2289 data->mState = state;
2290 command->mParam = data;
2291 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002292 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002293 sendCommand(command);
2294}
2295
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002296void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002297 int event,
2298 const record_client_info_t *clientInfo,
2299 const audio_config_base_t *clientConfig,
2300 std::vector<effect_descriptor_t> clientEffects,
2301 const audio_config_base_t *deviceConfig,
2302 std::vector<effect_descriptor_t> effects,
2303 audio_patch_handle_t patchHandle,
2304 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002305{
2306 sp<AudioCommand>command = new AudioCommand();
2307 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2308 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2309 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002310 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002311 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002312 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002313 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002314 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002315 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002316 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002317 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002318 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2319 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002320 sendCommand(command);
2321}
2322
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002323void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2324{
2325 sp<AudioCommand> command = new AudioCommand();
2326 command->mCommand = AUDIO_MODULES_UPDATE;
2327 sendCommand(command);
2328}
2329
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002330void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2331{
2332 sp<AudioCommand>command = new AudioCommand();
2333 command->mCommand = ROUTING_UPDATED;
2334 ALOGV("AudioCommandThread() adding routing update");
2335 sendCommand(command);
2336}
2337
Eric Laurent81dd0f52021-07-05 11:54:40 +02002338void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2339{
2340 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002341 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002342 ALOGV("AudioCommandThread() adding check spatializer");
2343 sendCommand(command);
2344}
2345
Eric Laurent15903592022-02-24 20:44:36 +01002346void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2347{
2348 sp<AudioCommand>command = new AudioCommand();
2349 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2350 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2351 sendCommand(command);
2352}
2353
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002354void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2355{
2356 sp<AudioCommand>command = new AudioCommand();
2357 command->mCommand = VOL_RANGE_INIT_REQUEST;
2358 ALOGV("AudioCommandThread() adding volume range init request");
2359 sendCommand(command);
2360}
2361
Eric Laurent0ede8922014-05-09 18:04:42 -07002362status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2363{
2364 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002365 audio_utils::lock_guard _l(mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002366 insertCommand_l(command, delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002367 mWaitWorkCV.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002368 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002369 audio_utils::unique_lock ul(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002370 while (command->mWaitStatus) {
2371 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002372 if (command->mCond.wait_for(
Andy Hung02ea2a02024-01-25 17:02:30 -08002373 ul, std::chrono::nanoseconds(timeOutNs), getTid()) == std::cv_status::timeout) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002374 command->mStatus = TIMED_OUT;
2375 command->mWaitStatus = false;
2376 }
2377 }
2378 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002379}
2380
Andy Hung79eacdb2023-11-30 19:34:24 -08002381// insertCommand_l() must be called with mMutex held
Eric Laurent0ede8922014-05-09 18:04:42 -07002382void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002383{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002384 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002385 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002386 command->mTime = systemTime() + milliseconds(delayMs);
2387
2388 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002389 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002390 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002391 }
2392
2393 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002394 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002395 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002396 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2397 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002398
2399 // create audio patch or release audio patch commands are equivalent
2400 // with regard to filtering
2401 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2402 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2403 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2404 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2405 continue;
2406 }
2407 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002408
2409 switch (command->mCommand) {
2410 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002411 ParametersData *data = (ParametersData *)command->mParam.get();
2412 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002413 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002414 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002415 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002416 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2417 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2418 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002419 String8 key;
2420 String8 value;
2421 param.getAt(j, key, value);
2422 for (size_t k = 0; k < param2.size(); k++) {
2423 String8 key2;
2424 String8 value2;
2425 param2.getAt(k, key2, value2);
2426 if (key2 == key) {
2427 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002428 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002429 break;
2430 }
2431 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002432 }
2433 // if all keys have been filtered out, remove the command.
2434 // otherwise, update the key value pairs
2435 if (param2.size() == 0) {
2436 removedCommands.add(command2);
2437 } else {
2438 data2->mKeyValuePairs = param2.toString();
2439 }
Eric Laurent21e54562013-09-23 12:08:05 -07002440 command->mTime = command2->mTime;
2441 // force delayMs to non 0 so that code below does not request to wait for
2442 // command status as the command is now delayed
2443 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002444 } break;
2445
2446 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002447 VolumeData *data = (VolumeData *)command->mParam.get();
2448 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002449 if (data->mIO != data2->mIO) break;
2450 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002451 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002452 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002453 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002454 command->mTime = command2->mTime;
2455 // force delayMs to non 0 so that code below does not request to wait for
2456 // command status as the command is now delayed
2457 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002458 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002459
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002460 case SET_VOICE_VOLUME: {
2461 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2462 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2463 ALOGV("Filtering out voice volume command value %f replaced by %f",
2464 data2->mVolume, data->mVolume);
2465 removedCommands.add(command2);
2466 command->mTime = command2->mTime;
2467 // force delayMs to non 0 so that code below does not request to wait for
2468 // command status as the command is now delayed
2469 delayMs = 1;
2470 } break;
2471
Eric Laurente45b48a2014-09-04 16:40:57 -07002472 case CREATE_AUDIO_PATCH:
2473 case RELEASE_AUDIO_PATCH: {
2474 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002475 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002476 if (command->mCommand == CREATE_AUDIO_PATCH) {
2477 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002478 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002479 } else {
2480 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002481 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002482 }
2483 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002484 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002485 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2486 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002487 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002488 } else {
2489 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002490 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002491 }
2492 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002493 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2494 same output. */
2495 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2496 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2497 bool isOutputDiff = false;
2498 if (patch.num_sources == patch2.num_sources) {
2499 for (unsigned count = 0; count < patch.num_sources; count++) {
2500 if (patch.sources[count].id != patch2.sources[count].id) {
2501 isOutputDiff = true;
2502 break;
2503 }
2504 }
2505 if (isOutputDiff)
2506 break;
2507 }
2508 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002509 ALOGV("Filtering out %s audio patch command for handle %d",
2510 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2511 removedCommands.add(command2);
2512 command->mTime = command2->mTime;
2513 // force delayMs to non 0 so that code below does not request to wait for
2514 // command status as the command is now delayed
2515 delayMs = 1;
2516 } break;
2517
Jean-Michel Trivide801052015-04-14 19:10:14 -07002518 case DYN_POLICY_MIX_STATE_UPDATE: {
2519
2520 } break;
2521
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002522 case RECORDING_CONFIGURATION_UPDATE: {
2523
2524 } break;
2525
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002526 case ROUTING_UPDATED: {
2527
2528 } break;
2529
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002530 case VOL_RANGE_INIT_REQUEST: {
2531 // command may come from different requests, do not filter
2532 } break;
2533
Mathias Agopian65ab4712010-07-14 17:59:35 -07002534 default:
2535 break;
2536 }
2537 }
2538
2539 // remove filtered commands
2540 for (size_t j = 0; j < removedCommands.size(); j++) {
2541 // removed commands always have time stamps greater than current command
2542 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002543 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002544 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002545 mAudioCommands.removeAt(k);
2546 break;
2547 }
2548 }
2549 }
2550 removedCommands.clear();
2551
Eric Laurentaa79bef2015-01-15 14:33:51 -08002552 // Disable wait for status if delay is not 0.
2553 // Except for create audio patch command because the returned patch handle
2554 // is needed by audio policy manager
2555 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002556 command->mWaitStatus = false;
2557 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002558
Mathias Agopian65ab4712010-07-14 17:59:35 -07002559 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002560 ALOGV("inserting command: %d at index %zd, num commands %zu",
2561 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002562 mAudioCommands.insertAt(command, i + 1);
2563}
2564
2565void AudioPolicyService::AudioCommandThread::exit()
2566{
Steve Block3856b092011-10-20 11:56:00 +01002567 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002568 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002569 audio_utils::lock_guard _l(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002570 requestExit();
Andy Hung79eacdb2023-11-30 19:34:24 -08002571 mWaitWorkCV.notify_one();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002572 }
Zach Janga754b4f2015-10-27 01:29:34 +00002573 // Note that we can call it from the thread loop if all other references have been released
2574 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002575 requestExitAndWait();
2576}
2577
2578void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2579{
2580 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2581 mCommand,
2582 (int)ns2s(mTime),
2583 (int)ns2ms(mTime)%1000,
2584 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002585 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002586}
2587
Dima Zavinfce7a472011-04-19 22:30:36 -07002588/******* helpers for the service_ops callbacks defined below *********/
2589void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2590 const char *keyValuePairs,
2591 int delayMs)
2592{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002593 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002594 delayMs);
2595}
2596
2597int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2598 float volume,
2599 audio_io_handle_t output,
2600 int delayMs)
2601{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002602 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002603 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002604}
2605
Dima Zavinfce7a472011-04-19 22:30:36 -07002606int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2607{
2608 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2609}
2610
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002611void AudioPolicyService::setEffectSuspended(int effectId,
2612 audio_session_t sessionId,
2613 bool suspended)
2614{
2615 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2616}
2617
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002618Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002619{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002620 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002621 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002622}
2623
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002624
Dima Zavinfce7a472011-04-19 22:30:36 -07002625extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002626audio_module_handle_t aps_load_hw_module(void *service __unused,
2627 const char *name);
2628audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002629 audio_devices_t *pDevices,
2630 uint32_t *pSamplingRate,
2631 audio_format_t *pFormat,
2632 audio_channel_mask_t *pChannelMask,
2633 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002634 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002635
Eric Laurent2d388ec2014-03-07 13:25:54 -08002636audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002637 audio_module_handle_t module,
2638 audio_devices_t *pDevices,
2639 uint32_t *pSamplingRate,
2640 audio_format_t *pFormat,
2641 audio_channel_mask_t *pChannelMask,
2642 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002643 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002644 const audio_offload_info_t *offloadInfo);
2645audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002646 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002647 audio_io_handle_t output2);
2648int aps_close_output(void *service __unused, audio_io_handle_t output);
2649int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2650int aps_restore_output(void *service __unused, audio_io_handle_t output);
2651audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002652 audio_devices_t *pDevices,
2653 uint32_t *pSamplingRate,
2654 audio_format_t *pFormat,
2655 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002656 audio_in_acoustics_t acoustics __unused);
2657audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002658 audio_module_handle_t module,
2659 audio_devices_t *pDevices,
2660 uint32_t *pSamplingRate,
2661 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002662 audio_channel_mask_t *pChannelMask);
2663int aps_close_input(void *service __unused, audio_io_handle_t input);
2664int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002665int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002666 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002667 audio_io_handle_t dst_output);
2668char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2669 const char *keys);
2670void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2671 const char *kv_pairs, int delay_ms);
2672int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002673 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002674 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002675int aps_set_voice_volume(void *service, float volume, int delay_ms);
2676};
Dima Zavinfce7a472011-04-19 22:30:36 -07002677
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002678} // namespace android