blob: cd010ab2f1b8f05b64cebfd6ac5dc61ca1ea7ecf [file] [log] [blame]
Mathias Agopian65ab4712010-07-14 17:59:35 -07001/*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "AudioPolicyService"
18//#define LOG_NDEBUG 0
19
Glenn Kasten153b9fe2013-07-15 11:23:36 -070020#include "Configuration.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070021#include <stdint.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070022#include <sys/time.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053023#include <dlfcn.h>
Mikhail Naganov959e2d02019-03-28 11:08:19 -070024
25#include <audio_utils/clock.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070026#include <binder/IServiceManager.h>
27#include <utils/Log.h>
28#include <cutils/properties.h>
29#include <binder/IPCThreadState.h>
Svet Ganovf4ddfef2018-01-16 07:37:58 -080030#include <binder/PermissionController.h>
31#include <binder/IResultReceiver.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070032#include <utils/String16.h>
33#include <utils/threads.h>
Atneya Nair5b1ed642023-06-23 14:43:37 -070034#include "AudioRecordClient.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070035#include "AudioPolicyService.h"
Mathias Agopian65ab4712010-07-14 17:59:35 -070036#include <hardware_legacy/power.h>
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -080037#include <media/AidlConversion.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070038#include <media/AudioEffect.h>
Chih-Hung Hsiehc84d9d22014-11-14 13:33:34 -080039#include <media/AudioParameter.h>
Andy Hungc747c532022-03-07 21:41:14 -080040#include <mediautils/MethodStatistics.h>
Andy Hungab7ef302018-05-15 19:35:29 -070041#include <mediautils/ServiceUtilities.h>
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080042#include <mediautils/TimeCheck.h>
Michael Groovercfd28302018-12-11 19:16:46 -080043#include <sensorprivacy/SensorPrivacyManager.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070044
Dima Zavin64760242011-05-11 14:15:23 -070045#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070046#include <system/audio_policy.h>
Mikhail Naganov68e3f642023-04-28 13:06:32 -070047#include <AudioPolicyConfig.h>
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053048#include <AudioPolicyManager.h>
Mikhail Naganov61a4fac2016-10-13 14:44:18 -070049
Mathias Agopian65ab4712010-07-14 17:59:35 -070050namespace android {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080051using binder::Status;
Shunkai Yao49bc61f2023-10-10 19:31:10 +000052using media::audio::common::Spatialization;
Mathias Agopian65ab4712010-07-14 17:59:35 -070053
Glenn Kasten8dad0e32012-01-09 08:41:22 -080054static const char kDeadlockedString[] = "AudioPolicyService may be deadlocked\n";
55static const char kCmdDeadlockedString[] = "AudioPolicyService command thread may be deadlocked\n";
Jaideep Sharmaba9053b2021-01-25 21:24:26 +053056static const char kAudioPolicyManagerCustomPath[] = "libaudiopolicymanagercustom.so";
Mathias Agopian65ab4712010-07-14 17:59:35 -070057
Mikhail Naganov959e2d02019-03-28 11:08:19 -070058static const int kDumpLockTimeoutNs = 1 * NANOS_PER_SECOND;
Mathias Agopian65ab4712010-07-14 17:59:35 -070059
Eric Laurent0ede8922014-05-09 18:04:42 -070060static const nsecs_t kAudioCommandTimeoutNs = seconds(3); // 3 seconds
Christer Fletcher5fa8c4b2013-01-18 15:27:03 +010061
Svet Ganovf4ddfef2018-01-16 07:37:58 -080062static const String16 sManageAudioPolicyPermission("android.permission.MANAGE_AUDIO_POLICY");
Dima Zavinfce7a472011-04-19 22:30:36 -070063
Andy Hungc747c532022-03-07 21:41:14 -080064// Creates an association between Binder code to name for IAudioPolicyService.
65#define IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST \
66BINDER_METHOD_ENTRY(onNewAudioModulesAvailable) \
67BINDER_METHOD_ENTRY(setDeviceConnectionState) \
68BINDER_METHOD_ENTRY(getDeviceConnectionState) \
69BINDER_METHOD_ENTRY(handleDeviceConfigChange) \
70BINDER_METHOD_ENTRY(setPhoneState) \
71BINDER_METHOD_ENTRY(setForceUse) \
72BINDER_METHOD_ENTRY(getForceUse) \
73BINDER_METHOD_ENTRY(getOutput) \
74BINDER_METHOD_ENTRY(getOutputForAttr) \
75BINDER_METHOD_ENTRY(startOutput) \
76BINDER_METHOD_ENTRY(stopOutput) \
77BINDER_METHOD_ENTRY(releaseOutput) \
78BINDER_METHOD_ENTRY(getInputForAttr) \
79BINDER_METHOD_ENTRY(startInput) \
80BINDER_METHOD_ENTRY(stopInput) \
81BINDER_METHOD_ENTRY(releaseInput) \
82BINDER_METHOD_ENTRY(initStreamVolume) \
83BINDER_METHOD_ENTRY(setStreamVolumeIndex) \
84BINDER_METHOD_ENTRY(getStreamVolumeIndex) \
85BINDER_METHOD_ENTRY(setVolumeIndexForAttributes) \
86BINDER_METHOD_ENTRY(getVolumeIndexForAttributes) \
87BINDER_METHOD_ENTRY(getMaxVolumeIndexForAttributes) \
88BINDER_METHOD_ENTRY(getMinVolumeIndexForAttributes) \
89BINDER_METHOD_ENTRY(getStrategyForStream) \
90BINDER_METHOD_ENTRY(getDevicesForAttributes) \
91BINDER_METHOD_ENTRY(getOutputForEffect) \
92BINDER_METHOD_ENTRY(registerEffect) \
93BINDER_METHOD_ENTRY(unregisterEffect) \
94BINDER_METHOD_ENTRY(setEffectEnabled) \
95BINDER_METHOD_ENTRY(moveEffectsToIo) \
96BINDER_METHOD_ENTRY(isStreamActive) \
97BINDER_METHOD_ENTRY(isStreamActiveRemotely) \
98BINDER_METHOD_ENTRY(isSourceActive) \
99BINDER_METHOD_ENTRY(queryDefaultPreProcessing) \
100BINDER_METHOD_ENTRY(addSourceDefaultEffect) \
101BINDER_METHOD_ENTRY(addStreamDefaultEffect) \
102BINDER_METHOD_ENTRY(removeSourceDefaultEffect) \
103BINDER_METHOD_ENTRY(removeStreamDefaultEffect) \
104BINDER_METHOD_ENTRY(setSupportedSystemUsages) \
105BINDER_METHOD_ENTRY(setAllowedCapturePolicy) \
106BINDER_METHOD_ENTRY(getOffloadSupport) \
107BINDER_METHOD_ENTRY(isDirectOutputSupported) \
108BINDER_METHOD_ENTRY(listAudioPorts) \
109BINDER_METHOD_ENTRY(getAudioPort) \
110BINDER_METHOD_ENTRY(createAudioPatch) \
111BINDER_METHOD_ENTRY(releaseAudioPatch) \
112BINDER_METHOD_ENTRY(listAudioPatches) \
113BINDER_METHOD_ENTRY(setAudioPortConfig) \
114BINDER_METHOD_ENTRY(registerClient) \
115BINDER_METHOD_ENTRY(setAudioPortCallbacksEnabled) \
116BINDER_METHOD_ENTRY(setAudioVolumeGroupCallbacksEnabled) \
117BINDER_METHOD_ENTRY(acquireSoundTriggerSession) \
118BINDER_METHOD_ENTRY(releaseSoundTriggerSession) \
119BINDER_METHOD_ENTRY(getPhoneState) \
120BINDER_METHOD_ENTRY(registerPolicyMixes) \
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200121BINDER_METHOD_ENTRY(updatePolicyMixes) \
Andy Hungc747c532022-03-07 21:41:14 -0800122BINDER_METHOD_ENTRY(setUidDeviceAffinities) \
123BINDER_METHOD_ENTRY(removeUidDeviceAffinities) \
124BINDER_METHOD_ENTRY(setUserIdDeviceAffinities) \
125BINDER_METHOD_ENTRY(removeUserIdDeviceAffinities) \
126BINDER_METHOD_ENTRY(startAudioSource) \
127BINDER_METHOD_ENTRY(stopAudioSource) \
128BINDER_METHOD_ENTRY(setMasterMono) \
129BINDER_METHOD_ENTRY(getMasterMono) \
130BINDER_METHOD_ENTRY(getStreamVolumeDB) \
131BINDER_METHOD_ENTRY(getSurroundFormats) \
132BINDER_METHOD_ENTRY(getReportedSurroundFormats) \
133BINDER_METHOD_ENTRY(getHwOffloadFormatsSupportedForBluetoothMedia) \
134BINDER_METHOD_ENTRY(setSurroundFormatEnabled) \
135BINDER_METHOD_ENTRY(setAssistantServicesUids) \
136BINDER_METHOD_ENTRY(setActiveAssistantServicesUids) \
137BINDER_METHOD_ENTRY(setA11yServicesUids) \
138BINDER_METHOD_ENTRY(setCurrentImeUid) \
139BINDER_METHOD_ENTRY(isHapticPlaybackSupported) \
140BINDER_METHOD_ENTRY(isUltrasoundSupported) \
Atneya Nair698f5ef2022-12-15 16:15:09 -0800141BINDER_METHOD_ENTRY(isHotwordStreamSupported) \
Andy Hungc747c532022-03-07 21:41:14 -0800142BINDER_METHOD_ENTRY(listAudioProductStrategies) \
143BINDER_METHOD_ENTRY(getProductStrategyFromAudioAttributes) \
144BINDER_METHOD_ENTRY(listAudioVolumeGroups) \
145BINDER_METHOD_ENTRY(getVolumeGroupFromAudioAttributes) \
146BINDER_METHOD_ENTRY(setRttEnabled) \
147BINDER_METHOD_ENTRY(isCallScreenModeSupported) \
148BINDER_METHOD_ENTRY(setDevicesRoleForStrategy) \
149BINDER_METHOD_ENTRY(removeDevicesRoleForStrategy) \
Paul Wang5d7cdb52022-11-22 09:45:06 +0000150BINDER_METHOD_ENTRY(clearDevicesRoleForStrategy) \
Andy Hungc747c532022-03-07 21:41:14 -0800151BINDER_METHOD_ENTRY(getDevicesForRoleAndStrategy) \
152BINDER_METHOD_ENTRY(setDevicesRoleForCapturePreset) \
153BINDER_METHOD_ENTRY(addDevicesRoleForCapturePreset) \
154BINDER_METHOD_ENTRY(removeDevicesRoleForCapturePreset) \
155BINDER_METHOD_ENTRY(clearDevicesRoleForCapturePreset) \
156BINDER_METHOD_ENTRY(getDevicesForRoleAndCapturePreset) \
157BINDER_METHOD_ENTRY(registerSoundTriggerCaptureStateListener) \
158BINDER_METHOD_ENTRY(getSpatializer) \
159BINDER_METHOD_ENTRY(canBeSpatialized) \
160BINDER_METHOD_ENTRY(getDirectPlaybackSupport) \
jiabina84c3d32022-12-02 18:59:55 +0000161BINDER_METHOD_ENTRY(getDirectProfilesForAttributes) \
162BINDER_METHOD_ENTRY(getSupportedMixerAttributes) \
163BINDER_METHOD_ENTRY(setPreferredMixerAttributes) \
164BINDER_METHOD_ENTRY(getPreferredMixerAttributes) \
165BINDER_METHOD_ENTRY(clearPreferredMixerAttributes) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100166BINDER_METHOD_ENTRY(getRegisteredPolicyMixes) \
Atneya Nair9f91a5e2024-05-09 16:25:05 -0700167BINDER_METHOD_ENTRY(getPermissionController) \
Marvin Raminbdefaf02023-11-01 09:10:32 +0100168 \
Andy Hungc747c532022-03-07 21:41:14 -0800169// singleton for Binder Method Statistics for IAudioPolicyService
170static auto& getIAudioPolicyServiceStatistics() {
171 using Code = int;
172
173#pragma push_macro("BINDER_METHOD_ENTRY")
174#undef BINDER_METHOD_ENTRY
175#define BINDER_METHOD_ENTRY(ENTRY) \
176 {(Code)media::BnAudioPolicyService::TRANSACTION_##ENTRY, #ENTRY},
177
178 static mediautils::MethodStatistics<Code> methodStatistics{
179 IAUDIOPOLICYSERVICE_BINDER_METHOD_MACRO_LIST
180 METHOD_STATISTICS_BINDER_CODE_NAMES(Code)
181 };
182#pragma pop_macro("BINDER_METHOD_ENTRY")
183
184 return methodStatistics;
185}
186
Mathias Agopian65ab4712010-07-14 17:59:35 -0700187// ----------------------------------------------------------------------------
188
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530189static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
190{
Mikhail Naganov9e459d72023-05-05 17:36:39 -0700191 AudioPolicyManager *apm = nullptr;
192 media::AudioPolicyConfig apmConfig;
193 if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {
194 auto config = AudioPolicyConfig::loadFromApmAidlConfigWithFallback(apmConfig);
195 LOG_ALWAYS_FATAL_IF(config->getEngineLibraryNameSuffix() !=
196 AudioPolicyConfig::kDefaultEngineLibraryNameSuffix,
197 "Only default engine is currently supported with the AIDL HAL");
198 apm = new AudioPolicyManager(config,
199 loadApmEngineLibraryAndCreateEngine(
200 config->getEngineLibraryNameSuffix(), apmConfig.engineConfig),
201 clientInterface);
202 } else {
203 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(); // This can't fail.
204 apm = new AudioPolicyManager(config,
205 loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
206 clientInterface);
207 }
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530208 status_t status = apm->initialize();
209 if (status != NO_ERROR) {
210 delete apm;
211 apm = nullptr;
212 }
213 return apm;
214}
215
216static void destroyAudioPolicyManager(AudioPolicyInterface *interface)
217{
218 delete interface;
219}
220// ----------------------------------------------------------------------------
221
Mathias Agopian65ab4712010-07-14 17:59:35 -0700222AudioPolicyService::AudioPolicyService()
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700223 : BnAudioPolicyService(),
Ytai Ben-Tsvi85093d52020-03-26 09:41:15 -0700224 mAudioPolicyManager(NULL),
225 mAudioPolicyClient(NULL),
226 mPhoneState(AUDIO_MODE_INVALID),
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530227 mCaptureStateNotifier(false),
228 mCreateAudioPolicyManager(createAudioPolicyManager),
Eric Laurent0d13fea2022-11-04 17:12:08 +0100229 mDestroyAudioPolicyManager(destroyAudioPolicyManager),
Atneya Nair9f91a5e2024-05-09 16:25:05 -0700230 mUsecaseValidator(media::createUsecaseValidator()),
231 mPermissionController(sp<NativePermissionController>::make())
232{
Andy Hung225aef62022-12-06 16:33:20 -0800233 setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
Andy Hung58b01b12024-03-26 18:04:29 -0700234 setInheritRt(true);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530235}
236
237void AudioPolicyService::loadAudioPolicyManager()
238{
239 mLibraryHandle = dlopen(kAudioPolicyManagerCustomPath, RTLD_NOW);
240 if (mLibraryHandle != nullptr) {
241 ALOGI("%s loading %s", __func__, kAudioPolicyManagerCustomPath);
242 mCreateAudioPolicyManager = reinterpret_cast<CreateAudioPolicyManagerInstance>
243 (dlsym(mLibraryHandle, "createAudioPolicyManager"));
244 const char *lastError = dlerror();
245 ALOGW_IF(mCreateAudioPolicyManager == nullptr, "%s createAudioPolicyManager is null %s",
246 __func__, lastError != nullptr ? lastError : "no error");
247
248 mDestroyAudioPolicyManager = reinterpret_cast<DestroyAudioPolicyManagerInstance>(
249 dlsym(mLibraryHandle, "destroyAudioPolicyManager"));
250 lastError = dlerror();
251 ALOGW_IF(mDestroyAudioPolicyManager == nullptr, "%s destroyAudioPolicyManager is null %s",
252 __func__, lastError != nullptr ? lastError : "no error");
253 if (mCreateAudioPolicyManager == nullptr || mDestroyAudioPolicyManager == nullptr){
254 unloadAudioPolicyManager();
255 LOG_ALWAYS_FATAL("could not find audiopolicymanager interface methods");
256 }
257 }
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700258}
259
260void AudioPolicyService::onFirstRef()
261{
Andy Hungd47aca22022-03-15 11:50:51 -0700262 // Log an AudioPolicy "constructor" mediametrics event on first ref.
263 // This records the time it takes to load the audio modules and devices.
264 mediametrics::Defer defer([beginNs = systemTime()] {
265 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
266 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_CTOR)
267 .set(AMEDIAMETRICS_PROP_EXECUTIONTIMENS, (int64_t)(systemTime() - beginNs))
268 .record(); });
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700269 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800270 audio_utils::lock_guard _l(mMutex);
Eric Laurent93575202011-01-18 18:39:02 -0800271
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700272 // start audio commands thread
273 mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);
274 // start output activity command thread
275 mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);
Eric Laurentdce54a12014-03-10 12:19:46 -0700276
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700277 mAudioPolicyClient = new AudioPolicyClient(this);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530278
279 loadAudioPolicyManager();
280 mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700281 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200282
bryant_liuba2b4392014-06-11 16:49:30 +0800283 // load audio processing modules
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000284 const sp<EffectsFactoryHalInterface> effectsFactoryHal = EffectsFactoryHalInterface::create();
Andy Hungd3595ed2023-12-19 15:34:46 -0800285 auto audioPolicyEffects = sp<AudioPolicyEffects>::make(effectsFactoryHal);
286 auto uidPolicy = sp<UidPolicy>::make(this);
287 auto sensorPrivacyPolicy = sp<SensorPrivacyPolicy>::make(this);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700288 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800289 audio_utils::lock_guard _l(mMutex);
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700290 mAudioPolicyEffects = audioPolicyEffects;
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000291 mUidPolicy = uidPolicy;
292 mSensorPrivacyPolicy = sensorPrivacyPolicy;
Eric Laurent8b1e80b2014-10-07 09:08:47 -0700293 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000294 uidPolicy->registerSelf();
295 sensorPrivacyPolicy->registerSelf();
Eric Laurentd66d7a12021-07-13 13:35:32 +0200296
Eric Laurent81dd0f52021-07-05 11:54:40 +0200297 // Create spatializer if supported
Eric Laurent52b0bd52021-09-27 15:25:40 +0200298 if (mAudioPolicyManager != nullptr) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800299 audio_utils::lock_guard _l(mMutex);
Eric Laurent52b0bd52021-09-27 15:25:40 +0200300 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
301 AudioDeviceTypeAddrVector devices;
302 bool hasSpatializer = mAudioPolicyManager->canBeSpatialized(&attr, nullptr, devices);
303 if (hasSpatializer) {
Andy Hung1040da52023-12-06 20:59:06 -0800304 // Unlock as Spatializer::create() will use the callback and acquire the
305 // AudioPolicyService_Mutex.
Andy Hung79eacdb2023-11-30 19:34:24 -0800306 mMutex.unlock();
Shunkai Yao8d6489a2023-04-18 23:14:25 +0000307 mSpatializer = Spatializer::create(this, effectsFactoryHal);
Andy Hung79eacdb2023-11-30 19:34:24 -0800308 mMutex.lock();
Eric Laurent52b0bd52021-09-27 15:25:40 +0200309 }
Andy Hung8aa43c02022-09-13 18:53:06 -0700310 if (mSpatializer == nullptr) {
311 // No spatializer created, signal the reason: NO_INIT a failure, OK means intended.
312 const status_t createStatus = hasSpatializer ? NO_INIT : OK;
313 Spatializer::sendEmptyCreateSpatializerMetricWithStatus(createStatus);
314 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200315 }
Eric Laurentd66d7a12021-07-13 13:35:32 +0200316 AudioSystem::audioPolicyReady();
Andy Hungb08b3752024-01-09 19:05:23 -0800317}
318
319void AudioPolicyService::onAudioSystemReady() {
320 sp<AudioPolicyEffects> audioPolicyEffects;
321 {
322 audio_utils::lock_guard _l(mMutex);
323
324 audioPolicyEffects = mAudioPolicyEffects;
325 }
326 audioPolicyEffects->initDefaultDeviceEffects();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700327}
328
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530329void AudioPolicyService::unloadAudioPolicyManager()
330{
331 ALOGV("%s ", __func__);
332 if (mLibraryHandle != nullptr) {
333 dlclose(mLibraryHandle);
334 }
335 mLibraryHandle = nullptr;
336 mCreateAudioPolicyManager = nullptr;
337 mDestroyAudioPolicyManager = nullptr;
338}
339
Mathias Agopian65ab4712010-07-14 17:59:35 -0700340AudioPolicyService::~AudioPolicyService()
341{
Mathias Agopian65ab4712010-07-14 17:59:35 -0700342 mAudioCommandThread->exit();
Eric Laurent657ff612014-05-07 11:58:24 -0700343 mOutputCommandThread->exit();
Eric Laurent7c7f10b2011-06-17 21:29:58 -0700344
Jaideep Sharmaba9053b2021-01-25 21:24:26 +0530345 mDestroyAudioPolicyManager(mAudioPolicyManager);
346 unloadAudioPolicyManager();
347
Eric Laurentdce54a12014-03-10 12:19:46 -0700348 delete mAudioPolicyClient;
Eric Laurentb52c1522014-05-20 11:27:36 -0700349
350 mNotificationClients.clear();
bryant_liuba2b4392014-06-11 16:49:30 +0800351 mAudioPolicyEffects.clear();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800352
353 mUidPolicy->unregisterSelf();
Michael Groovercfd28302018-12-11 19:16:46 -0800354 mSensorPrivacyPolicy->unregisterSelf();
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000355
356 mUidPolicy.clear();
Michael Groovercfd28302018-12-11 19:16:46 -0800357 mSensorPrivacyPolicy.clear();
Eric Laurentb52c1522014-05-20 11:27:36 -0700358}
359
360// A notification client is always registered by AudioSystem when the client process
361// connects to AudioPolicyService.
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800362Status AudioPolicyService::registerClient(const sp<media::IAudioPolicyServiceClient>& client)
Eric Laurentb52c1522014-05-20 11:27:36 -0700363{
Eric Laurent12590252015-08-21 18:40:20 -0700364 if (client == 0) {
365 ALOGW("%s got NULL client", __FUNCTION__);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800366 return Status::ok();
Eric Laurent12590252015-08-21 18:40:20 -0700367 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800368 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700369
370 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800371 pid_t pid = IPCThreadState::self()->getCallingPid();
372 int64_t token = ((int64_t)uid<<32) | pid;
373
374 if (mNotificationClients.indexOfKey(token) < 0) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700375 sp<NotificationClient> notificationClient = new NotificationClient(this,
376 client,
luochaojiang908c7d72018-06-21 14:58:04 +0800377 uid,
378 pid);
379 ALOGV("registerClient() client %p, uid %d pid %d", client.get(), uid, pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700380
luochaojiang908c7d72018-06-21 14:58:04 +0800381 mNotificationClients.add(token, notificationClient);
Eric Laurentb52c1522014-05-20 11:27:36 -0700382
Marco Nelissenf8880202014-11-14 07:58:25 -0800383 sp<IBinder> binder = IInterface::asBinder(client);
Eric Laurentb52c1522014-05-20 11:27:36 -0700384 binder->linkToDeath(notificationClient);
385 }
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800386 return Status::ok();
Eric Laurentb52c1522014-05-20 11:27:36 -0700387}
388
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800389Status AudioPolicyService::setAudioPortCallbacksEnabled(bool enabled)
Eric Laurente8726fe2015-06-26 09:39:24 -0700390{
Andy Hung79eacdb2023-11-30 19:34:24 -0800391 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurente8726fe2015-06-26 09:39:24 -0700392
393 uid_t uid = IPCThreadState::self()->getCallingUid();
luochaojiang908c7d72018-06-21 14:58:04 +0800394 pid_t pid = IPCThreadState::self()->getCallingPid();
395 int64_t token = ((int64_t)uid<<32) | pid;
396
397 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800398 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700399 }
luochaojiang908c7d72018-06-21 14:58:04 +0800400 mNotificationClients.valueFor(token)->setAudioPortCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800401 return Status::ok();
Eric Laurente8726fe2015-06-26 09:39:24 -0700402}
403
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800404Status AudioPolicyService::setAudioVolumeGroupCallbacksEnabled(bool enabled)
François Gaffiecfe17322018-11-07 13:41:29 +0100405{
Andy Hung79eacdb2023-11-30 19:34:24 -0800406 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100407
408 uid_t uid = IPCThreadState::self()->getCallingUid();
409 pid_t pid = IPCThreadState::self()->getCallingPid();
410 int64_t token = ((int64_t)uid<<32) | pid;
411
412 if (mNotificationClients.indexOfKey(token) < 0) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800413 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100414 }
415 mNotificationClients.valueFor(token)->setAudioVolumeGroupCallbacksEnabled(enabled);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800416 return Status::ok();
François Gaffiecfe17322018-11-07 13:41:29 +0100417}
418
Eric Laurentb52c1522014-05-20 11:27:36 -0700419// removeNotificationClient() is called when the client process dies.
luochaojiang908c7d72018-06-21 14:58:04 +0800420void AudioPolicyService::removeNotificationClient(uid_t uid, pid_t pid)
Eric Laurentb52c1522014-05-20 11:27:36 -0700421{
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000422 bool hasSameUid = false;
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800423 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800424 audio_utils::lock_guard _l(mNotificationClientsMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800425 int64_t token = ((int64_t)uid<<32) | pid;
426 mNotificationClients.removeItem(token);
luochaojiang908c7d72018-06-21 14:58:04 +0800427 for (size_t i = 0; i < mNotificationClients.size(); i++) {
428 if (mNotificationClients.valueAt(i)->uid() == uid) {
429 hasSameUid = true;
430 break;
431 }
432 }
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000433 }
434 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800435 audio_utils::lock_guard _l(mMutex);
luochaojiang908c7d72018-06-21 14:58:04 +0800436 if (mAudioPolicyManager && !hasSameUid) {
Eric Laurent10b71232018-04-13 18:14:44 -0700437 // called from binder death notification: no need to clear caller identity
Eric Laurent8c7e6da2015-04-21 17:37:00 -0700438 mAudioPolicyManager->releaseResourcesForUid(uid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700439 }
Eric Laurent0ebd5f92014-11-19 19:04:52 -0800440 }
Eric Laurentb52c1522014-05-20 11:27:36 -0700441}
442
443void AudioPolicyService::onAudioPortListUpdate()
444{
445 mOutputCommandThread->updateAudioPortListCommand();
446}
447
448void AudioPolicyService::doOnAudioPortListUpdate()
449{
Andy Hung79eacdb2023-11-30 19:34:24 -0800450 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700451 for (size_t i = 0; i < mNotificationClients.size(); i++) {
452 mNotificationClients.valueAt(i)->onAudioPortListUpdate();
453 }
454}
455
456void AudioPolicyService::onAudioPatchListUpdate()
457{
458 mOutputCommandThread->updateAudioPatchListCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700459}
460
Eric Laurentb52c1522014-05-20 11:27:36 -0700461void AudioPolicyService::doOnAudioPatchListUpdate()
462{
Andy Hung79eacdb2023-11-30 19:34:24 -0800463 audio_utils::lock_guard _l(mNotificationClientsMutex);
Eric Laurentb52c1522014-05-20 11:27:36 -0700464 for (size_t i = 0; i < mNotificationClients.size(); i++) {
465 mNotificationClients.valueAt(i)->onAudioPatchListUpdate();
466 }
467}
468
François Gaffiecfe17322018-11-07 13:41:29 +0100469void AudioPolicyService::onAudioVolumeGroupChanged(volume_group_t group, int flags)
470{
471 mOutputCommandThread->changeAudioVolumeGroupCommand(group, flags);
472}
473
474void AudioPolicyService::doOnAudioVolumeGroupChanged(volume_group_t group, int flags)
475{
Andy Hung79eacdb2023-11-30 19:34:24 -0800476 audio_utils::lock_guard _l(mNotificationClientsMutex);
François Gaffiecfe17322018-11-07 13:41:29 +0100477 for (size_t i = 0; i < mNotificationClients.size(); i++) {
478 mNotificationClients.valueAt(i)->onAudioVolumeGroupChanged(group, flags);
479 }
480}
481
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700482void AudioPolicyService::onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700483{
484 ALOGV("AudioPolicyService::onDynamicPolicyMixStateUpdate(%s, %d)",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000485 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700486 mOutputCommandThread->dynamicPolicyMixStateUpdateCommand(regId, state);
487}
488
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700489void AudioPolicyService::doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700490{
Andy Hung79eacdb2023-11-30 19:34:24 -0800491 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700492 for (size_t i = 0; i < mNotificationClients.size(); i++) {
493 mNotificationClients.valueAt(i)->onDynamicPolicyMixStateUpdate(regId, state);
494 }
495}
496
Eric Laurenta9f86652018-11-28 17:23:11 -0800497void AudioPolicyService::onRecordingConfigurationUpdate(
498 int event,
499 const record_client_info_t *clientInfo,
500 const audio_config_base_t *clientConfig,
501 std::vector<effect_descriptor_t> clientEffects,
502 const audio_config_base_t *deviceConfig,
503 std::vector<effect_descriptor_t> effects,
504 audio_patch_handle_t patchHandle,
505 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800506{
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800507 mOutputCommandThread->recordingConfigurationUpdateCommand(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800508 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800509}
510
Eric Laurenta9f86652018-11-28 17:23:11 -0800511void AudioPolicyService::doOnRecordingConfigurationUpdate(
512 int event,
513 const record_client_info_t *clientInfo,
514 const audio_config_base_t *clientConfig,
515 std::vector<effect_descriptor_t> clientEffects,
516 const audio_config_base_t *deviceConfig,
517 std::vector<effect_descriptor_t> effects,
518 audio_patch_handle_t patchHandle,
519 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800520{
Andy Hung79eacdb2023-11-30 19:34:24 -0800521 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800522 for (size_t i = 0; i < mNotificationClients.size(); i++) {
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800523 mNotificationClients.valueAt(i)->onRecordingConfigurationUpdate(event, clientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -0800524 clientConfig, clientEffects, deviceConfig, effects, patchHandle, source);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800525 }
526}
527
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700528void AudioPolicyService::onRoutingUpdated()
529{
530 mOutputCommandThread->routingChangedCommand();
531}
532
533void AudioPolicyService::doOnRoutingUpdated()
534{
Andy Hung79eacdb2023-11-30 19:34:24 -0800535 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700536 for (size_t i = 0; i < mNotificationClients.size(); i++) {
537 mNotificationClients.valueAt(i)->onRoutingUpdated();
538 }
539}
540
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000541void AudioPolicyService::onVolumeRangeInitRequest()
542{
543 mOutputCommandThread->volRangeInitReqCommand();
544}
545
546void AudioPolicyService::doOnVolumeRangeInitRequest()
547{
Andy Hung79eacdb2023-11-30 19:34:24 -0800548 audio_utils::lock_guard _l(mNotificationClientsMutex);
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000549 for (size_t i = 0; i < mNotificationClients.size(); i++) {
550 mNotificationClients.valueAt(i)->onVolumeRangeInitRequest();
551 }
552}
553
Eric Laurent81dd0f52021-07-05 11:54:40 +0200554void AudioPolicyService::onCheckSpatializer()
555{
Andy Hung79eacdb2023-11-30 19:34:24 -0800556 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200557 onCheckSpatializer_l();
558}
559
560void AudioPolicyService::onCheckSpatializer_l()
561{
562 if (mSpatializer != nullptr) {
563 mOutputCommandThread->checkSpatializerCommand();
564 }
Eric Laurent81dd0f52021-07-05 11:54:40 +0200565}
566
567void AudioPolicyService::doOnCheckSpatializer()
568{
Eric Laurentd6bee3a2022-08-31 16:07:50 +0200569 ALOGV("%s mSpatializer %p level %d",
570 __func__, mSpatializer.get(), (int)mSpatializer->getLevel());
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200571
Eric Laurent39095982021-08-24 18:29:27 +0200572 if (mSpatializer != nullptr) {
Eric Laurent52b0bd52021-09-27 15:25:40 +0200573 // Note: mSpatializer != nullptr => mAudioPolicyManager != nullptr
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000574 if (mSpatializer->getLevel() != Spatialization::Level::NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200575 audio_io_handle_t currentOutput = mSpatializer->getOutput();
576 audio_io_handle_t newOutput;
577 const audio_attributes_t attr = attributes_initializer(AUDIO_USAGE_MEDIA);
578 audio_config_base_t config = mSpatializer->getAudioInConfig();
Eric Laurent21270b62022-07-04 15:11:29 +0200579
Andy Hung79eacdb2023-11-30 19:34:24 -0800580 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200581 status_t status =
582 mAudioPolicyManager->getSpatializerOutput(&config, &attr, &newOutput);
Eric Laurentb4f42a92022-01-17 17:37:31 +0100583 ALOGV("%s currentOutput %d newOutput %d channel_mask %#x",
584 __func__, currentOutput, newOutput, config.channel_mask);
Eric Laurent39095982021-08-24 18:29:27 +0200585 if (status == NO_ERROR && currentOutput == newOutput) {
586 return;
587 }
Eric Laurent15903592022-02-24 20:44:36 +0100588 size_t numActiveTracks = countActiveClientsOnOutput_l(newOutput);
Andy Hung79eacdb2023-11-30 19:34:24 -0800589 mMutex.unlock();
Eric Laurent39095982021-08-24 18:29:27 +0200590 // It is OK to call detachOutput() is none is already attached.
591 mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200592 if (status == NO_ERROR && newOutput != AUDIO_IO_HANDLE_NONE) {
593 status = mSpatializer->attachOutput(newOutput, numActiveTracks);
Eric Laurent39095982021-08-24 18:29:27 +0200594 }
Andy Hung79eacdb2023-11-30 19:34:24 -0800595 mMutex.lock();
Eric Laurent39095982021-08-24 18:29:27 +0200596 if (status != NO_ERROR) {
597 mAudioPolicyManager->releaseSpatializerOutput(newOutput);
598 }
Shunkai Yao49bc61f2023-10-10 19:31:10 +0000599 } else if (mSpatializer->getLevel() == Spatialization::Level::NONE &&
600 mSpatializer->getOutput() != AUDIO_IO_HANDLE_NONE) {
Eric Laurent39095982021-08-24 18:29:27 +0200601 audio_io_handle_t output = mSpatializer->detachOutput();
Eric Laurent21270b62022-07-04 15:11:29 +0200602
Eric Laurent39095982021-08-24 18:29:27 +0200603 if (output != AUDIO_IO_HANDLE_NONE) {
Andy Hung79eacdb2023-11-30 19:34:24 -0800604 audio_utils::lock_guard _l(mMutex);
Eric Laurent39095982021-08-24 18:29:27 +0200605 mAudioPolicyManager->releaseSpatializerOutput(output);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200606 }
607 }
608 }
609}
610
Eric Laurent11094172022-04-05 18:27:42 +0200611size_t AudioPolicyService::countActiveClientsOnOutput_l(
612 audio_io_handle_t output, bool spatializedOnly) {
Eric Laurent15903592022-02-24 20:44:36 +0100613 size_t count = 0;
614 for (size_t i = 0; i < mAudioPlaybackClients.size(); i++) {
615 auto client = mAudioPlaybackClients.valueAt(i);
Eric Laurent11094172022-04-05 18:27:42 +0200616 if (client->io == output && client->active
617 && (!spatializedOnly || client->isSpatialized)) {
Eric Laurent15903592022-02-24 20:44:36 +0100618 count++;
619 }
620 }
621 return count;
622}
623
624void AudioPolicyService::onUpdateActiveSpatializerTracks_l() {
625 if (mSpatializer == nullptr) {
626 return;
627 }
628 mOutputCommandThread->updateActiveSpatializerTracksCommand();
629}
630
631void AudioPolicyService::doOnUpdateActiveSpatializerTracks()
632{
Eric Laurent21270b62022-07-04 15:11:29 +0200633 if (mSpatializer == nullptr) {
634 return;
635 }
636 audio_io_handle_t output = mSpatializer->getOutput();
Eric Laurent7ea0d1b2022-04-01 14:23:44 +0200637 size_t activeClients;
638 {
Andy Hung79eacdb2023-11-30 19:34:24 -0800639 audio_utils::lock_guard _l(mMutex);
Eric Laurent21270b62022-07-04 15:11:29 +0200640 activeClients = countActiveClientsOnOutput_l(output);
Eric Laurent15903592022-02-24 20:44:36 +0100641 }
Eric Laurent21270b62022-07-04 15:11:29 +0200642 mSpatializer->updateActiveTracks(activeClients);
Eric Laurent15903592022-02-24 20:44:36 +0100643}
644
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800645status_t AudioPolicyService::clientCreateAudioPatch(const struct audio_patch *patch,
646 audio_patch_handle_t *handle,
647 int delayMs)
648{
649 return mAudioCommandThread->createAudioPatchCommand(patch, handle, delayMs);
650}
651
652status_t AudioPolicyService::clientReleaseAudioPatch(audio_patch_handle_t handle,
653 int delayMs)
654{
655 return mAudioCommandThread->releaseAudioPatchCommand(handle, delayMs);
656}
657
Eric Laurente1715a42014-05-20 11:30:42 -0700658status_t AudioPolicyService::clientSetAudioPortConfig(const struct audio_port_config *config,
659 int delayMs)
660{
661 return mAudioCommandThread->setAudioPortConfigCommand(config, delayMs);
662}
663
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800664AudioPolicyService::NotificationClient::NotificationClient(
665 const sp<AudioPolicyService>& service,
666 const sp<media::IAudioPolicyServiceClient>& client,
667 uid_t uid,
668 pid_t pid)
luochaojiang908c7d72018-06-21 14:58:04 +0800669 : mService(service), mUid(uid), mPid(pid), mAudioPolicyServiceClient(client),
François Gaffiecfe17322018-11-07 13:41:29 +0100670 mAudioPortCallbacksEnabled(false), mAudioVolumeGroupCallbacksEnabled(false)
Eric Laurentb52c1522014-05-20 11:27:36 -0700671{
672}
673
674AudioPolicyService::NotificationClient::~NotificationClient()
675{
676}
677
678void AudioPolicyService::NotificationClient::binderDied(const wp<IBinder>& who __unused)
679{
680 sp<NotificationClient> keep(this);
681 sp<AudioPolicyService> service = mService.promote();
682 if (service != 0) {
luochaojiang908c7d72018-06-21 14:58:04 +0800683 service->removeNotificationClient(mUid, mPid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700684 }
685}
686
687void AudioPolicyService::NotificationClient::onAudioPortListUpdate()
688{
Eric Laurente8726fe2015-06-26 09:39:24 -0700689 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700690 mAudioPolicyServiceClient->onAudioPortListUpdate();
691 }
692}
693
694void AudioPolicyService::NotificationClient::onAudioPatchListUpdate()
695{
Eric Laurente8726fe2015-06-26 09:39:24 -0700696 if (mAudioPolicyServiceClient != 0 && mAudioPortCallbacksEnabled) {
Eric Laurentb52c1522014-05-20 11:27:36 -0700697 mAudioPolicyServiceClient->onAudioPatchListUpdate();
698 }
699}
Eric Laurent57dae992011-07-24 13:36:09 -0700700
Pattydd807582021-11-04 21:01:03 +0800701void AudioPolicyService::NotificationClient::onAudioVolumeGroupChanged(volume_group_t group,
François Gaffiecfe17322018-11-07 13:41:29 +0100702 int flags)
703{
704 if (mAudioPolicyServiceClient != 0 && mAudioVolumeGroupCallbacksEnabled) {
705 mAudioPolicyServiceClient->onAudioVolumeGroupChanged(group, flags);
706 }
707}
708
709
Jean-Michel Trivide801052015-04-14 19:10:14 -0700710void AudioPolicyService::NotificationClient::onDynamicPolicyMixStateUpdate(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700711 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -0700712{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700713 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800714 mAudioPolicyServiceClient->onDynamicPolicyMixStateUpdate(
715 legacy2aidl_String8_string(regId).value(), state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800716 }
717}
718
719void AudioPolicyService::NotificationClient::onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800720 int event,
721 const record_client_info_t *clientInfo,
722 const audio_config_base_t *clientConfig,
723 std::vector<effect_descriptor_t> clientEffects,
724 const audio_config_base_t *deviceConfig,
725 std::vector<effect_descriptor_t> effects,
726 audio_patch_handle_t patchHandle,
727 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800728{
Andy Hung4ef19fa2018-05-15 19:35:29 -0700729 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800730 status_t status = [&]() -> status_t {
731 int32_t eventAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(event));
732 media::RecordClientInfo clientInfoAidl = VALUE_OR_RETURN_STATUS(
733 legacy2aidl_record_client_info_t_RecordClientInfo(*clientInfo));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700734 AudioConfigBase clientConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700735 legacy2aidl_audio_config_base_t_AudioConfigBase(
736 *clientConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800737 std::vector<media::EffectDescriptor> clientEffectsAidl = VALUE_OR_RETURN_STATUS(
738 convertContainer<std::vector<media::EffectDescriptor>>(
739 clientEffects,
740 legacy2aidl_effect_descriptor_t_EffectDescriptor));
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700741 AudioConfigBase deviceConfigAidl = VALUE_OR_RETURN_STATUS(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700742 legacy2aidl_audio_config_base_t_AudioConfigBase(
743 *deviceConfig, true /*isInput*/));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800744 std::vector<media::EffectDescriptor> effectsAidl = VALUE_OR_RETURN_STATUS(
745 convertContainer<std::vector<media::EffectDescriptor>>(
746 effects,
747 legacy2aidl_effect_descriptor_t_EffectDescriptor));
748 int32_t patchHandleAidl = VALUE_OR_RETURN_STATUS(
749 legacy2aidl_audio_patch_handle_t_int32_t(patchHandle));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700750 media::audio::common::AudioSource sourceAidl = VALUE_OR_RETURN_STATUS(
751 legacy2aidl_audio_source_t_AudioSource(source));
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800752 return aidl_utils::statusTFromBinderStatus(
753 mAudioPolicyServiceClient->onRecordingConfigurationUpdate(eventAidl,
754 clientInfoAidl,
755 clientConfigAidl,
756 clientEffectsAidl,
757 deviceConfigAidl,
758 effectsAidl,
759 patchHandleAidl,
760 sourceAidl));
761 }();
762 ALOGW_IF(status != OK, "onRecordingConfigurationUpdate() failed: %d", status);
Jean-Michel Trivide801052015-04-14 19:10:14 -0700763 }
764}
765
Eric Laurente8726fe2015-06-26 09:39:24 -0700766void AudioPolicyService::NotificationClient::setAudioPortCallbacksEnabled(bool enabled)
767{
768 mAudioPortCallbacksEnabled = enabled;
769}
770
François Gaffiecfe17322018-11-07 13:41:29 +0100771void AudioPolicyService::NotificationClient::setAudioVolumeGroupCallbacksEnabled(bool enabled)
772{
773 mAudioVolumeGroupCallbacksEnabled = enabled;
774}
Eric Laurente8726fe2015-06-26 09:39:24 -0700775
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700776void AudioPolicyService::NotificationClient::onRoutingUpdated()
777{
778 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
779 mAudioPolicyServiceClient->onRoutingUpdated();
780 }
781}
782
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000783void AudioPolicyService::NotificationClient::onVolumeRangeInitRequest()
784{
785 if (mAudioPolicyServiceClient != 0 && isServiceUid(mUid)) {
786 mAudioPolicyServiceClient->onVolumeRangeInitRequest();
787 }
788}
789
Mathias Agopian65ab4712010-07-14 17:59:35 -0700790void AudioPolicyService::binderDied(const wp<IBinder>& who) {
Glenn Kasten411e4472012-11-02 10:00:06 -0700791 ALOGW("binderDied() %p, calling pid %d", who.unsafe_get(),
Eric Laurentde070132010-07-13 04:45:46 -0700792 IPCThreadState::self()->getCallingPid());
Mathias Agopian65ab4712010-07-14 17:59:35 -0700793}
794
Andy Hung79eacdb2023-11-30 19:34:24 -0800795static void dumpReleaseLock(audio_utils::mutex& mutex, bool locked)
796 RELEASE(mutex) NO_THREAD_SAFETY_ANALYSIS
Mikhail Naganov12b716c2020-04-30 22:37:43 +0000797{
798 if (locked) mutex.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -0700799}
800
801status_t AudioPolicyService::dumpInternals(int fd)
802{
803 const size_t SIZE = 256;
804 char buffer[SIZE];
805 String8 result;
806
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000807 snprintf(buffer, SIZE, "Supported System Usages:\n ");
Hayden Gomes524159d2019-12-23 14:41:47 -0800808 result.append(buffer);
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000809 std::stringstream msg;
810 size_t i = 0;
811 for (auto usage : mSupportedSystemUsages) {
812 if (i++ != 0) msg << ", ";
813 if (const char* strUsage = audio_usage_to_string(usage); strUsage) {
814 msg << strUsage;
815 } else {
816 msg << usage << " (unknown)";
817 }
Hayden Gomes524159d2019-12-23 14:41:47 -0800818 }
Mikhail Naganovb3bcb4f2022-02-23 23:46:56 +0000819 if (i == 0) {
820 msg << "None";
821 }
822 msg << std::endl;
823 result.append(msg.str().c_str());
Hayden Gomes524159d2019-12-23 14:41:47 -0800824
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +0000825 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -0800826
827 mUidPolicy->dumpInternals(fd);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700828 return NO_ERROR;
829}
830
Eric Laurente8c8b432018-10-17 10:08:02 -0700831void AudioPolicyService::updateUidStates()
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800832{
Andy Hung79eacdb2023-11-30 19:34:24 -0800833 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700834 updateUidStates_l();
835}
836
837void AudioPolicyService::updateUidStates_l()
838{
Eric Laurent4eb58f12018-12-07 16:41:02 -0800839// Go over all active clients and allow capture (does not force silence) in the
840// following cases:
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800841// The client is in the active assistant list
842// AND is TOP
843// AND an accessibility service is TOP
844// AND source is either VOICE_RECOGNITION OR HOTWORD
845// OR there is no active privacy sensitive capture or call
846// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
847// AND source is VOICE_RECOGNITION OR HOTWORD
848// The client is an assistant AND active assistant is not being used
Evan Severson1f700cd2021-02-10 13:10:37 -0800849// AND an accessibility service is on TOP or a RTT call is active
Eric Laurent589171c2019-07-25 18:04:29 -0700850// AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800851// OR there is no active privacy sensitive capture or call
Evan Severson1f700cd2021-02-10 13:10:37 -0800852// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800853// AND is TOP most recent assistant and uses VOICE_RECOGNITION or HOTWORD
854// OR there is no top recent assistant and source is HOTWORD
Evan Severson1f700cd2021-02-10 13:10:37 -0800855// OR The client is an accessibility service
856// AND Is on TOP
857// AND the source is VOICE_RECOGNITION or HOTWORD
858// OR The assistant is not on TOP
Eric Laurent589171c2019-07-25 18:04:29 -0700859// AND there is no active privacy sensitive capture or call
860// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Evan Severson1f700cd2021-02-10 13:10:37 -0800861// AND is on TOP
862// AND the source is VOICE_RECOGNITION or HOTWORD
863// OR the client source is virtual (remote submix, call audio TX or RX...)
864// OR the client source is HOTWORD
865// AND is on TOP
866// OR all active clients are using HOTWORD source
867// AND no call is active
868// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
869// OR the client is the current InputMethodService
870// AND a RTT call is active AND the source is VOICE_RECOGNITION
871// OR Any client
872// AND The assistant is not on TOP
873// AND is on TOP or latest started
874// AND there is no active privacy sensitive capture or call
875// OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4eb58f12018-12-07 16:41:02 -0800876
Eric Laurent4e947da2019-10-17 15:24:06 -0700877
Eric Laurent4eb58f12018-12-07 16:41:02 -0800878 sp<AudioRecordClient> topActive;
879 sp<AudioRecordClient> latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800880 sp<AudioRecordClient> topSensitiveActive;
Eric Laurentb809a752020-06-29 09:53:13 -0700881 sp<AudioRecordClient> latestSensitiveActiveOrComm;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800882 sp<AudioRecordClient> latestActiveAssistant;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700883
Eric Laurenta46bedb2018-12-07 18:01:26 -0800884 nsecs_t topStartNs = 0;
885 nsecs_t latestStartNs = 0;
Eric Laurentc21d5692020-02-25 10:24:36 -0800886 nsecs_t topSensitiveStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800887 nsecs_t latestSensitiveStartNs = 0;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800888 nsecs_t latestAssistantStartNs = 0;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800889 bool isA11yOnTop = mUidPolicy->isA11yOnTop();
890 bool isAssistantOnTop = false;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800891 bool useActiveAssistantList = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800892 bool isSensitiveActive = false;
Eric Laurent1ff16a72019-03-14 18:35:04 -0700893 bool isInCall = mPhoneState == AUDIO_MODE_IN_CALL;
Eric Laurentc21d5692020-02-25 10:24:36 -0800894 bool isInCommunication = mPhoneState == AUDIO_MODE_IN_COMMUNICATION;
895 bool rttCallActive = (isInCall || isInCommunication)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700896 && mUidPolicy->isRttEnabled();
Eric Laurent4e947da2019-10-17 15:24:06 -0700897 bool onlyHotwordActive = true;
Eric Laurentb809a752020-06-29 09:53:13 -0700898 bool isPhoneStateOwnerActive = false;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800899
Michael Groovercfd28302018-12-11 19:16:46 -0800900 // if Sensor Privacy is enabled then all recordings should be silenced.
901 if (mSensorPrivacyPolicy->isSensorPrivacyEnabled()) {
902 silenceAllRecordings_l();
903 return;
904 }
905
Eric Laurente8c8b432018-10-17 10:08:02 -0700906 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
907 sp<AudioRecordClient> current = mAudioRecordClients[i];
Svet Ganov33761132021-05-13 22:51:08 +0000908 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
909 current->attributionSource.uid));
Evan Severson1f700cd2021-02-10 13:10:37 -0800910 if (!current->active) {
Eric Laurent1ff16a72019-03-14 18:35:04 -0700911 continue;
Eric Laurent4eb58f12018-12-07 16:41:02 -0800912 }
Eric Laurent1ff16a72019-03-14 18:35:04 -0700913
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700914 app_state_t appState = apmStatFromAmState(mUidPolicy->getUidState(currentUid));
Eric Laurent1ff16a72019-03-14 18:35:04 -0700915 // clients which app is in IDLE state are not eligible for top active or
916 // latest active
917 if (appState == APP_STATE_IDLE) {
918 continue;
919 }
920
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700921 bool isAccessibility = mUidPolicy->isA11yUid(currentUid);
Eric Laurent14a88632020-07-16 12:28:30 -0700922 // Clients capturing for Accessibility services or virtual sources are not considered
Eric Laurentc21d5692020-02-25 10:24:36 -0800923 // for top or latest active to avoid masking regular clients started before
Eric Laurent14a88632020-07-16 12:28:30 -0700924 if (!isAccessibility && !isVirtualSource(current->attributes.source)) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700925 bool isAssistant = mUidPolicy->isAssistantUid(currentUid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800926 bool isActiveAssistant = mUidPolicy->isActiveAssistantUid(currentUid);
Eric Laurentc21d5692020-02-25 10:24:36 -0800927 bool isPrivacySensitive =
928 (current->attributes.flags & AUDIO_FLAG_CAPTURE_PRIVATE) != 0;
Eric Laurentb809a752020-06-29 09:53:13 -0700929
Eric Laurentc21d5692020-02-25 10:24:36 -0800930 if (appState == APP_STATE_TOP) {
931 if (isPrivacySensitive) {
932 if (current->startTimeNs > topSensitiveStartNs) {
933 topSensitiveActive = current;
934 topSensitiveStartNs = current->startTimeNs;
935 }
936 } else {
937 if (current->startTimeNs > topStartNs) {
938 topActive = current;
939 topStartNs = current->startTimeNs;
940 }
941 }
942 if (isAssistant) {
943 isAssistantOnTop = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800944 if (isActiveAssistant) {
945 useActiveAssistantList = true;
946 } else if (!useActiveAssistantList) {
947 if (current->startTimeNs > latestAssistantStartNs) {
948 latestActiveAssistant = current;
949 latestAssistantStartNs = current->startTimeNs;
950 }
951 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800952 }
Eric Laurenta46bedb2018-12-07 18:01:26 -0800953 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800954 // Clients capturing for HOTWORD are not considered
955 // for latest active to avoid masking regular clients started before
956 if (!(current->attributes.source == AUDIO_SOURCE_HOTWORD
957 || ((isA11yOnTop || rttCallActive) && isAssistant))) {
958 if (isPrivacySensitive) {
Eric Laurentb809a752020-06-29 09:53:13 -0700959 // if audio mode is IN_COMMUNICATION, make sure the audio mode owner
960 // is marked latest sensitive active even if another app qualifies.
961 if (current->startTimeNs > latestSensitiveStartNs
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700962 || (isInCommunication && currentUid == mPhoneStateOwnerUid)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700963 if (!isInCommunication || latestSensitiveActiveOrComm == nullptr
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700964 || VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +0000965 latestSensitiveActiveOrComm->attributionSource.uid))
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700966 != mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -0700967 latestSensitiveActiveOrComm = current;
968 latestSensitiveStartNs = current->startTimeNs;
969 }
Eric Laurentc21d5692020-02-25 10:24:36 -0800970 }
971 isSensitiveActive = true;
972 } else {
973 if (current->startTimeNs > latestStartNs) {
974 latestActive = current;
975 latestStartNs = current->startTimeNs;
976 }
977 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800978 }
979 }
François Gaffiedb1a4412023-10-10 17:32:33 +0000980 if (current->attributes.source != AUDIO_SOURCE_HOTWORD &&
981 !isVirtualSource(current->attributes.source)) {
Eric Laurent4e947da2019-10-17 15:24:06 -0700982 onlyHotwordActive = false;
983 }
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100984 if (currentUid == mPhoneStateOwnerUid &&
985 !isVirtualSource(current->attributes.source)) {
Eric Laurentb809a752020-06-29 09:53:13 -0700986 isPhoneStateOwnerActive = true;
987 }
Eric Laurent4eb58f12018-12-07 16:41:02 -0800988 }
989
Eric Laurent1ff16a72019-03-14 18:35:04 -0700990 // if no active client with UI on Top, consider latest active as top
991 if (topActive == nullptr) {
992 topActive = latestActive;
Eric Laurentc21d5692020-02-25 10:24:36 -0800993 topStartNs = latestStartNs;
994 }
995 if (topSensitiveActive == nullptr) {
Eric Laurentb809a752020-06-29 09:53:13 -0700996 topSensitiveActive = latestSensitiveActiveOrComm;
Eric Laurentc21d5692020-02-25 10:24:36 -0800997 topSensitiveStartNs = latestSensitiveStartNs;
Eric Laurentb809a752020-06-29 09:53:13 -0700998 } else if (latestSensitiveActiveOrComm != nullptr) {
999 // if audio mode is IN_COMMUNICATION, favor audio mode owner over an app with
1000 // foreground UI in case both are capturing with privacy sensitive flag.
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001001 uid_t latestActiveUid = VALUE_OR_FATAL(
Svet Ganov33761132021-05-13 22:51:08 +00001002 aidl2legacy_int32_t_uid_t(latestSensitiveActiveOrComm->attributionSource.uid));
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001003 if (isInCommunication && latestActiveUid == mPhoneStateOwnerUid) {
Eric Laurentb809a752020-06-29 09:53:13 -07001004 topSensitiveActive = latestSensitiveActiveOrComm;
1005 topSensitiveStartNs = latestSensitiveStartNs;
1006 }
Eric Laurentc21d5692020-02-25 10:24:36 -08001007 }
1008
1009 // If both privacy sensitive and regular capture are active:
1010 // if the regular capture is privileged
1011 // allow concurrency
1012 // else
1013 // favor the privacy sensitive case
1014 if (topActive != nullptr && topSensitiveActive != nullptr
Ricardo Correa57a37692020-03-23 17:27:25 -07001015 && !topActive->canCaptureOutput) {
Eric Laurentc21d5692020-02-25 10:24:36 -08001016 topActive = nullptr;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001017 }
1018
1019 for (size_t i =0; i < mAudioRecordClients.size(); i++) {
1020 sp<AudioRecordClient> current = mAudioRecordClients[i];
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001021 uid_t currentUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001022 current->attributionSource.uid));
Eric Laurent1ff16a72019-03-14 18:35:04 -07001023 if (!current->active) {
1024 continue;
1025 }
1026
Eric Laurent4eb58f12018-12-07 16:41:02 -08001027 audio_source_t source = current->attributes.source;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001028 bool isTopOrLatestActive = topActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001029 current->attributionSource.uid == topActive->attributionSource.uid;
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001030 bool isTopOrLatestSensitive = topSensitiveActive == nullptr ? false :
Svet Ganov33761132021-05-13 22:51:08 +00001031 current->attributionSource.uid == topSensitiveActive->attributionSource.uid;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001032 bool isTopOrLatestAssistant = latestActiveAssistant == nullptr ? false :
1033 current->attributionSource.uid == latestActiveAssistant->attributionSource.uid;
Eric Laurentc21d5692020-02-25 10:24:36 -08001034
Andy Hung79eacdb2023-11-30 19:34:24 -08001035 auto canCaptureIfInCallOrCommunication = [&](const auto &recordClient) REQUIRES(mMutex) {
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001036 uid_t recordUid = VALUE_OR_FATAL(aidl2legacy_int32_t_uid_t(
Svet Ganov33761132021-05-13 22:51:08 +00001037 recordClient->attributionSource.uid));
Ricardo Correa57a37692020-03-23 17:27:25 -07001038 bool canCaptureCall = recordClient->canCaptureOutput;
Eric Laurentb809a752020-06-29 09:53:13 -07001039 bool canCaptureCommunication = recordClient->canCaptureOutput
1040 || !isPhoneStateOwnerActive
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001041 || recordUid == mPhoneStateOwnerUid;
Eric Laurentb809a752020-06-29 09:53:13 -07001042 return !(isInCall && !canCaptureCall)
1043 && !(isInCommunication && !canCaptureCommunication);
Eric Laurentc21d5692020-02-25 10:24:36 -08001044 };
Eric Laurent1ff16a72019-03-14 18:35:04 -07001045
1046 // By default allow capture if:
1047 // The assistant is not on TOP
Eric Laurenta171e352019-05-07 13:04:45 -07001048 // AND is on TOP or latest started
Eric Laurent1ff16a72019-03-14 18:35:04 -07001049 // AND there is no active privacy sensitive capture or call
1050 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent4ab18412022-11-07 16:25:32 +01001051 bool allowSensitiveCapture =
1052 !isSensitiveActive || isTopOrLatestSensitive || current->canCaptureOutput;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001053 bool allowCapture = !isAssistantOnTop
Eric Laurentc21d5692020-02-25 10:24:36 -08001054 && (isTopOrLatestActive || isTopOrLatestSensitive)
Eric Laurent4ab18412022-11-07 16:25:32 +01001055 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001056 && canCaptureIfInCallOrCommunication(current);
Eric Laurent2dc962b2019-03-01 08:25:25 -08001057
Eric Laurented726cc2021-07-01 14:26:41 +02001058 if (!current->hasOp()) {
1059 // Never allow capture if app op is denied
1060 allowCapture = false;
1061 } else if (isVirtualSource(source)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001062 // Allow capture for virtual (remote submix, call audio TX or RX...) sources
1063 allowCapture = true;
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001064 } else if (!useActiveAssistantList && mUidPolicy->isAssistantUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001065 // For assistant allow capture if:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001066 // Active assistant list is not being used
1067 // AND accessibility service is on TOP or a RTT call is active
Eric Laurent1ff16a72019-03-14 18:35:04 -07001068 // AND the source is VOICE_RECOGNITION or HOTWORD
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001069 // OR there is no active privacy sensitive capture or call
1070 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1071 // AND is latest TOP assistant AND
1072 // uses VOICE_RECOGNITION OR uses HOTWORD
1073 // OR there is no TOP assistant and uses HOTWORD
Eric Laurent6ede98f2019-06-11 14:50:30 -07001074 if (isA11yOnTop || rttCallActive) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001075 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001076 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001077 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001078 } else if (allowSensitiveCapture
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001079 && canCaptureIfInCallOrCommunication(current)) {
1080 if (isTopOrLatestAssistant
1081 && (source == AUDIO_SOURCE_VOICE_RECOGNITION
1082 || source == AUDIO_SOURCE_HOTWORD)) {
1083 allowCapture = true;
1084 } else if (!isAssistantOnTop && (source == AUDIO_SOURCE_HOTWORD)) {
1085 allowCapture = true;
1086 }
1087 }
1088 } else if (useActiveAssistantList && mUidPolicy->isActiveAssistantUid(currentUid)) {
1089 // For assistant on active list and on top allow capture if:
1090 // An accessibility service is on TOP
1091 // AND the source is VOICE_RECOGNITION or HOTWORD
1092 // OR there is no active privacy sensitive capture or call
1093 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
1094 // AND uses VOICE_RECOGNITION OR uses HOTWORD
1095 if (isA11yOnTop) {
1096 if (source == AUDIO_SOURCE_HOTWORD || source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1097 allowCapture = true;
1098 }
Eric Laurent4ab18412022-11-07 16:25:32 +01001099 } else if (allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001100 && canCaptureIfInCallOrCommunication(current)) {
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001101 if ((source == AUDIO_SOURCE_VOICE_RECOGNITION) || (source == AUDIO_SOURCE_HOTWORD))
1102 {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001103 allowCapture = true;
Eric Laurent4eb58f12018-12-07 16:41:02 -08001104 }
1105 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001106 } else if (mUidPolicy->isA11yUid(currentUid)) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001107 // For accessibility service allow capture if:
Eric Laurent47670c92019-08-28 16:59:05 -07001108 // The assistant is not on TOP
1109 // AND there is no active privacy sensitive capture or call
Eric Laurent589171c2019-07-25 18:04:29 -07001110 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurent47670c92019-08-28 16:59:05 -07001111 // OR
1112 // Is on TOP AND the source is VOICE_RECOGNITION or HOTWORD
1113 if (!isAssistantOnTop
Eric Laurent4ab18412022-11-07 16:25:32 +01001114 && allowSensitiveCapture
Eric Laurentc21d5692020-02-25 10:24:36 -08001115 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent47670c92019-08-28 16:59:05 -07001116 allowCapture = true;
1117 }
Eric Laurent589171c2019-07-25 18:04:29 -07001118 if (isA11yOnTop) {
1119 if (source == AUDIO_SOURCE_VOICE_RECOGNITION || source == AUDIO_SOURCE_HOTWORD) {
1120 allowCapture = true;
1121 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001122 }
Eric Laurent4e947da2019-10-17 15:24:06 -07001123 } else if (source == AUDIO_SOURCE_HOTWORD) {
1124 // For HOTWORD source allow capture when not on TOP if:
1125 // All active clients are using HOTWORD source
1126 // AND no call is active
1127 // OR client has CAPTURE_AUDIO_OUTPUT privileged permission
Eric Laurentc21d5692020-02-25 10:24:36 -08001128 if (onlyHotwordActive
1129 && canCaptureIfInCallOrCommunication(current)) {
Eric Laurent4e947da2019-10-17 15:24:06 -07001130 allowCapture = true;
1131 }
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001132 } else if (mUidPolicy->isCurrentImeUid(currentUid)) {
Kohsuke Yatoha623a132020-03-24 20:10:26 -07001133 // For current InputMethodService allow capture if:
1134 // A RTT call is active AND the source is VOICE_RECOGNITION
1135 if (rttCallActive && source == AUDIO_SOURCE_VOICE_RECOGNITION) {
1136 allowCapture = true;
1137 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001138 }
Eric Laurent8c7ef892021-06-10 13:32:16 +02001139 setAppState_l(current,
Philip P. Moltmannbda45752020-07-17 16:41:18 -07001140 allowCapture ? apmStatFromAmState(mUidPolicy->getUidState(currentUid)) :
Eric Laurent1ff16a72019-03-14 18:35:04 -07001141 APP_STATE_IDLE);
Eric Laurente8c8b432018-10-17 10:08:02 -07001142 }
1143}
1144
Michael Groovercfd28302018-12-11 19:16:46 -08001145void AudioPolicyService::silenceAllRecordings_l() {
1146 for (size_t i = 0; i < mAudioRecordClients.size(); i++) {
1147 sp<AudioRecordClient> current = mAudioRecordClients[i];
Eric Laurent1ff16a72019-03-14 18:35:04 -07001148 if (!isVirtualSource(current->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001149 setAppState_l(current, APP_STATE_IDLE);
Eric Laurent1ff16a72019-03-14 18:35:04 -07001150 }
Michael Groovercfd28302018-12-11 19:16:46 -08001151 }
1152}
1153
Eric Laurente8c8b432018-10-17 10:08:02 -07001154/* static */
1155app_state_t AudioPolicyService::apmStatFromAmState(int amState) {
Eric Laurent1ff16a72019-03-14 18:35:04 -07001156
1157 if (amState == ActivityManager::PROCESS_STATE_UNKNOWN) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001158 return APP_STATE_IDLE;
Eric Laurent1ff16a72019-03-14 18:35:04 -07001159 } else if (amState <= ActivityManager::PROCESS_STATE_TOP) {
1160 // include persistent services
1161 return APP_STATE_TOP;
Eric Laurente8c8b432018-10-17 10:08:02 -07001162 }
1163 return APP_STATE_FOREGROUND;
1164}
1165
Eric Laurent4eb58f12018-12-07 16:41:02 -08001166/* static */
Eric Laurent2dc962b2019-03-01 08:25:25 -08001167bool AudioPolicyService::isVirtualSource(audio_source_t source)
Eric Laurent4eb58f12018-12-07 16:41:02 -08001168{
1169 switch (source) {
1170 case AUDIO_SOURCE_VOICE_UPLINK:
1171 case AUDIO_SOURCE_VOICE_DOWNLINK:
1172 case AUDIO_SOURCE_VOICE_CALL:
Eric Laurent2dc962b2019-03-01 08:25:25 -08001173 case AUDIO_SOURCE_REMOTE_SUBMIX:
1174 case AUDIO_SOURCE_FM_TUNER:
Eric Laurent68eb2122020-04-30 17:40:57 -07001175 case AUDIO_SOURCE_ECHO_REFERENCE:
Eric Laurent4eb58f12018-12-07 16:41:02 -08001176 return true;
1177 default:
1178 break;
1179 }
1180 return false;
1181}
1182
Eric Laurent8c7ef892021-06-10 13:32:16 +02001183void AudioPolicyService::setAppState_l(sp<AudioRecordClient> client, app_state_t state)
Eric Laurente8c8b432018-10-17 10:08:02 -07001184{
1185 AutoCallerClear acc;
1186
1187 if (mAudioPolicyManager) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001188 mAudioPolicyManager->setAppState(client->portId, state);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001189 }
1190 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1191 if (af) {
Eric Laurentf32108e2018-10-04 17:22:04 -07001192 bool silenced = state == APP_STATE_IDLE;
Eric Laurent8c7ef892021-06-10 13:32:16 +02001193 if (client->silenced != silenced) {
1194 if (client->active) {
1195 if (silenced) {
Marvin Raminb03b49f2024-04-04 16:25:31 +02001196 finishRecording(client->attributionSource, client->virtualDeviceId,
1197 client->attributes.source);
Eric Laurent8c7ef892021-06-10 13:32:16 +02001198 } else {
1199 std::stringstream msg;
1200 msg << "Audio recording un-silenced on session " << client->session;
Marvin Raminb03b49f2024-04-04 16:25:31 +02001201 if (!startRecording(client->attributionSource, client->virtualDeviceId,
1202 String16(msg.str().c_str()), client->attributes.source)) {
Eric Laurent8c7ef892021-06-10 13:32:16 +02001203 silenced = true;
1204 }
1205 }
1206 }
1207 af->setRecordSilenced(client->portId, silenced);
1208 client->silenced = silenced;
1209 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001210 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001211}
1212
Glenn Kasten0f11b512014-01-31 16:18:54 -08001213status_t AudioPolicyService::dump(int fd, const Vector<String16>& args __unused)
Andy Hung79eacdb2023-11-30 19:34:24 -08001214NO_THREAD_SAFETY_ANALYSIS // update for trylock.
Mathias Agopian65ab4712010-07-14 17:59:35 -07001215{
Glenn Kasten44deb052012-02-05 18:09:08 -08001216 if (!dumpAllowed()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001217 dumpPermissionDenial(fd);
1218 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001219 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001220 if (!locked) {
1221 String8 result(kDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001222 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001223 }
1224
1225 dumpInternals(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001226
1227 String8 actPtr = String8::format("AudioCommandThread: %p\n", mAudioCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001228 write(fd, actPtr.c_str(), actPtr.size());
Glenn Kasten9d1f02d2012-02-08 17:47:58 -08001229 if (mAudioCommandThread != 0) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001230 mAudioCommandThread->dump(fd);
1231 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001232
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001233 String8 octPtr = String8::format("OutputCommandThread: %p\n", mOutputCommandThread.get());
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001234 write(fd, octPtr.c_str(), octPtr.size());
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001235 if (mOutputCommandThread != 0) {
1236 mOutputCommandThread->dump(fd);
1237 }
1238
Eric Laurentdce54a12014-03-10 12:19:46 -07001239 if (mAudioPolicyManager) {
1240 mAudioPolicyManager->dump(fd);
Mikhail Naganov1b22e542022-02-25 04:24:49 +00001241 } else {
1242 String8 apmPtr = String8::format("AudioPolicyManager: %p\n", mAudioPolicyManager);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001243 write(fd, apmPtr.c_str(), apmPtr.size());
Eric Laurentdce54a12014-03-10 12:19:46 -07001244 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001245
Kevin Rocard8be94972019-02-22 13:26:25 -08001246 mPackageManager.dump(fd);
1247
Andy Hung79eacdb2023-11-30 19:34:24 -08001248 dumpReleaseLock(mMutex, locked);
Andy Hungc747c532022-03-07 21:41:14 -08001249
Shunkai Yao59b27bc2022-07-22 18:42:27 +00001250 if (mSpatializer != nullptr) {
1251 std::string dumpString = mSpatializer->toString(1 /* level */);
1252 write(fd, dumpString.c_str(), dumpString.size());
1253 } else {
1254 String8 spatializerPtr = String8::format("Spatializer no supportted on this device\n");
1255 write(fd, spatializerPtr.c_str(), spatializerPtr.size());
1256 }
1257
Andy Hungc747c532022-03-07 21:41:14 -08001258 {
1259 std::string timeCheckStats = getIAudioPolicyServiceStatistics().dump();
1260 dprintf(fd, "\nIAudioPolicyService binder call profile\n");
1261 write(fd, timeCheckStats.c_str(), timeCheckStats.size());
1262 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07001263 }
1264 return NO_ERROR;
1265}
1266
1267status_t AudioPolicyService::dumpPermissionDenial(int fd)
1268{
1269 const size_t SIZE = 256;
1270 char buffer[SIZE];
1271 String8 result;
1272 snprintf(buffer, SIZE, "Permission Denial: "
1273 "can't dump AudioPolicyService from pid=%d, uid=%d\n",
1274 IPCThreadState::self()->getCallingPid(),
1275 IPCThreadState::self()->getCallingUid());
1276 result.append(buffer);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001277 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001278 return NO_ERROR;
1279}
1280
1281status_t AudioPolicyService::onTransact(
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001282 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001283 // make sure transactions reserved to AudioFlinger do not come from other processes
1284 switch (code) {
1285 case TRANSACTION_startOutput:
1286 case TRANSACTION_stopOutput:
1287 case TRANSACTION_releaseOutput:
1288 case TRANSACTION_getInputForAttr:
1289 case TRANSACTION_startInput:
1290 case TRANSACTION_stopInput:
1291 case TRANSACTION_releaseInput:
1292 case TRANSACTION_getOutputForEffect:
1293 case TRANSACTION_registerEffect:
1294 case TRANSACTION_unregisterEffect:
1295 case TRANSACTION_setEffectEnabled:
1296 case TRANSACTION_getStrategyForStream:
1297 case TRANSACTION_getOutputForAttr:
1298 case TRANSACTION_moveEffectsToIo:
1299 ALOGW("%s: transaction %d received from PID %d",
1300 __func__, code, IPCThreadState::self()->getCallingPid());
1301 return INVALID_OPERATION;
1302 default:
1303 break;
1304 }
1305
1306 // make sure the following transactions come from system components
1307 switch (code) {
1308 case TRANSACTION_setDeviceConnectionState:
1309 case TRANSACTION_handleDeviceConfigChange:
1310 case TRANSACTION_setPhoneState:
1311//FIXME: Allow setForceUse calls from system apps until a better use case routing API is available
1312// case TRANSACTION_setForceUse:
1313 case TRANSACTION_initStreamVolume:
1314 case TRANSACTION_setStreamVolumeIndex:
1315 case TRANSACTION_setVolumeIndexForAttributes:
1316 case TRANSACTION_getStreamVolumeIndex:
1317 case TRANSACTION_getVolumeIndexForAttributes:
1318 case TRANSACTION_getMinVolumeIndexForAttributes:
1319 case TRANSACTION_getMaxVolumeIndexForAttributes:
1320 case TRANSACTION_isStreamActive:
1321 case TRANSACTION_isStreamActiveRemotely:
1322 case TRANSACTION_isSourceActive:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001323 case TRANSACTION_registerPolicyMixes:
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +02001324 case TRANSACTION_updatePolicyMixes:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001325 case TRANSACTION_setMasterMono:
1326 case TRANSACTION_getSurroundFormats:
Kriti Dang6537def2021-03-02 13:46:59 +01001327 case TRANSACTION_getReportedSurroundFormats:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001328 case TRANSACTION_setSurroundFormatEnabled:
Oscar Azucena829d90d2022-01-28 17:17:56 -08001329 case TRANSACTION_setAssistantServicesUids:
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001330 case TRANSACTION_setActiveAssistantServicesUids:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001331 case TRANSACTION_setA11yServicesUids:
1332 case TRANSACTION_setUidDeviceAffinities:
1333 case TRANSACTION_removeUidDeviceAffinities:
1334 case TRANSACTION_setUserIdDeviceAffinities:
1335 case TRANSACTION_removeUserIdDeviceAffinities:
Pattydd807582021-11-04 21:01:03 +08001336 case TRANSACTION_getHwOffloadFormatsSupportedForBluetoothMedia:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001337 case TRANSACTION_listAudioVolumeGroups:
1338 case TRANSACTION_getVolumeGroupFromAudioAttributes:
1339 case TRANSACTION_acquireSoundTriggerSession:
1340 case TRANSACTION_releaseSoundTriggerSession:
Atneya Nair698f5ef2022-12-15 16:15:09 -08001341 case TRANSACTION_isHotwordStreamSupported:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001342 case TRANSACTION_setRttEnabled:
1343 case TRANSACTION_isCallScreenModeSupported:
1344 case TRANSACTION_setDevicesRoleForStrategy:
1345 case TRANSACTION_setSupportedSystemUsages:
1346 case TRANSACTION_removeDevicesRoleForStrategy:
Paul Wang5d7cdb52022-11-22 09:45:06 +00001347 case TRANSACTION_clearDevicesRoleForStrategy:
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001348 case TRANSACTION_getDevicesForRoleAndStrategy:
1349 case TRANSACTION_getDevicesForAttributes:
1350 case TRANSACTION_setAllowedCapturePolicy:
1351 case TRANSACTION_onNewAudioModulesAvailable:
1352 case TRANSACTION_setCurrentImeUid:
1353 case TRANSACTION_registerSoundTriggerCaptureStateListener:
1354 case TRANSACTION_setDevicesRoleForCapturePreset:
1355 case TRANSACTION_addDevicesRoleForCapturePreset:
1356 case TRANSACTION_removeDevicesRoleForCapturePreset:
1357 case TRANSACTION_clearDevicesRoleForCapturePreset:
Eric Laurent81dd0f52021-07-05 11:54:40 +02001358 case TRANSACTION_getDevicesForRoleAndCapturePreset:
jiabina84c3d32022-12-02 18:59:55 +00001359 case TRANSACTION_getSpatializer:
1360 case TRANSACTION_setPreferredMixerAttributes:
Marvin Raminbdefaf02023-11-01 09:10:32 +01001361 case TRANSACTION_clearPreferredMixerAttributes:
1362 case TRANSACTION_getRegisteredPolicyMixes: {
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001363 if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {
1364 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1365 __func__, code, IPCThreadState::self()->getCallingPid(),
1366 IPCThreadState::self()->getCallingUid());
1367 return INVALID_OPERATION;
1368 }
1369 } break;
1370 default:
1371 break;
1372 }
1373
Atneya Nair9f91a5e2024-05-09 16:25:05 -07001374 switch (code) {
1375 case TRANSACTION_getPermissionController: {
1376 if (!isAudioServerOrSystemServerUid(IPCThreadState::self()->getCallingUid())) {
1377 ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",
1378 __func__, code, IPCThreadState::self()->getCallingPid(),
1379 IPCThreadState::self()->getCallingUid());
1380 return INVALID_OPERATION;
1381 }
1382 }
1383 }
1384
Andy Hungc747c532022-03-07 21:41:14 -08001385 const std::string methodName = getIAudioPolicyServiceStatistics().getMethodForCode(code);
1386 mediautils::TimeCheck check(
1387 std::string("IAudioPolicyService::").append(methodName),
1388 [code, methodName](bool timeout, float elapsedMs) { // don't move methodName.
1389 if (timeout) {
1390 mediametrics::LogItem(AMEDIAMETRICS_KEY_AUDIO_POLICY)
1391 .set(AMEDIAMETRICS_PROP_EVENT, AMEDIAMETRICS_PROP_EVENT_VALUE_TIMEOUT)
1392 .set(AMEDIAMETRICS_PROP_METHODCODE, int64_t(code))
1393 .set(AMEDIAMETRICS_PROP_METHODNAME, methodName.c_str())
1394 .record();
1395 } else {
1396 getIAudioPolicyServiceStatistics().event(code, elapsedMs);
1397 }
Andy Hung741b3dd2022-06-13 19:49:43 -07001398 }, mediautils::TimeCheck::kDefaultTimeoutDuration,
1399 mediautils::TimeCheck::kDefaultSecondChanceDuration,
1400 true /* crashOnTimeout */);
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08001401
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001402 switch (code) {
1403 case SHELL_COMMAND_TRANSACTION: {
1404 int in = data.readFileDescriptor();
1405 int out = data.readFileDescriptor();
1406 int err = data.readFileDescriptor();
1407 int argc = data.readInt32();
1408 Vector<String16> args;
1409 for (int i = 0; i < argc && data.dataAvail() > 0; i++) {
1410 args.add(data.readString16());
1411 }
1412 sp<IBinder> unusedCallback;
1413 sp<IResultReceiver> resultReceiver;
1414 status_t status;
1415 if ((status = data.readNullableStrongBinder(&unusedCallback)) != NO_ERROR) {
1416 return status;
1417 }
1418 if ((status = data.readNullableStrongBinder(&resultReceiver)) != NO_ERROR) {
1419 return status;
1420 }
1421 status = shellCommand(in, out, err, args);
1422 if (resultReceiver != nullptr) {
1423 resultReceiver->send(status);
1424 }
1425 return NO_ERROR;
1426 }
1427 }
1428
Mathias Agopian65ab4712010-07-14 17:59:35 -07001429 return BnAudioPolicyService::onTransact(code, data, reply, flags);
1430}
1431
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001432// ------------------- Shell command implementation -------------------
1433
1434// NOTE: This is a remote API - make sure all args are validated
1435status_t AudioPolicyService::shellCommand(int in, int out, int err, Vector<String16>& args) {
1436 if (!checkCallingPermission(sManageAudioPolicyPermission, nullptr, nullptr)) {
1437 return PERMISSION_DENIED;
1438 }
1439 if (in == BAD_TYPE || out == BAD_TYPE || err == BAD_TYPE) {
1440 return BAD_VALUE;
1441 }
Atneya Nair56a436a2024-04-03 11:11:58 -07001442 if (args.size() >= 1 && args[0] == String16("purge_permission-cache")) {
Eric Laurent269acb42021-04-23 16:53:22 +02001443 purgePermissionCache();
1444 return NO_ERROR;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001445 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001446 return BAD_VALUE;
1447}
1448
Eric Laurent0d13fea2022-11-04 17:12:08 +01001449status_t AudioPolicyService::registerOutput(audio_io_handle_t output,
1450 const audio_config_base_t& config,
1451 const audio_output_flags_t flags) {
1452 return mUsecaseValidator->registerStream(output, config, flags);
1453}
1454
1455status_t AudioPolicyService::unregisterOutput(audio_io_handle_t output) {
1456 return mUsecaseValidator->unregisterStream(output);
1457}
1458
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001459// ----------- AudioPolicyService::UidPolicy implementation ----------
1460
1461void AudioPolicyService::UidPolicy::registerSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001462 status_t res = mAm.linkToDeath(this);
1463 mAm.registerUidObserver(this, ActivityManager::UID_OBSERVER_GONE
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001464 | ActivityManager::UID_OBSERVER_IDLE
Eric Laurente8c8b432018-10-17 10:08:02 -07001465 | ActivityManager::UID_OBSERVER_ACTIVE
1466 | ActivityManager::UID_OBSERVER_PROCSTATE,
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001467 ActivityManager::PROCESS_STATE_UNKNOWN,
1468 String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001469 if (!res) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001470 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001471 mObserverRegistered = true;
1472 } else {
1473 ALOGE("UidPolicy::registerSelf linkToDeath failed: %d", res);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001474
Steven Moreland2f348142019-07-02 15:59:07 -07001475 mAm.unregisterUidObserver(this);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001476 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001477}
1478
1479void AudioPolicyService::UidPolicy::unregisterSelf() {
Steven Moreland2f348142019-07-02 15:59:07 -07001480 mAm.unlinkToDeath(this);
1481 mAm.unregisterUidObserver(this);
Andy Hung79eacdb2023-11-30 19:34:24 -08001482 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001483 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001484}
1485
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001486void AudioPolicyService::UidPolicy::binderDied(__unused const wp<IBinder> &who) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001487 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001488 mCachedUids.clear();
1489 mObserverRegistered = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001490}
1491
Eric Laurente8c8b432018-10-17 10:08:02 -07001492void AudioPolicyService::UidPolicy::checkRegistered() {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001493 bool needToReregister = false;
1494 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001495 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001496 needToReregister = !mObserverRegistered;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001497 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001498 if (needToReregister) {
1499 // Looks like ActivityManager has died previously, attempt to re-register.
1500 registerSelf();
1501 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001502}
1503
1504bool AudioPolicyService::UidPolicy::isUidActive(uid_t uid) {
1505 if (isServiceUid(uid)) return true;
1506 checkRegistered();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001507 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001508 audio_utils::lock_guard _l(mMutex);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001509 // In an absense of the ActivityManager, assume everything to be active.
1510 if (!mObserverRegistered) return true;
1511 auto cacheIter = mCachedUids.find(uid);
Mikhail Naganoveba668a2018-04-05 08:13:15 -07001512 if (cacheIter != mCachedUids.end()) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001513 return cacheIter->second.first;
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001514 }
1515 }
1516 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001517 bool active = am.isUidActive(uid, String16("audioserver"));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001518 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001519 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001520 mCachedUids.insert(std::pair<uid_t,
1521 std::pair<bool, int>>(uid, std::pair<bool, int>(active,
1522 ActivityManager::PROCESS_STATE_UNKNOWN)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001523 }
1524 return active;
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001525}
1526
Eric Laurente8c8b432018-10-17 10:08:02 -07001527int AudioPolicyService::UidPolicy::getUidState(uid_t uid) {
1528 if (isServiceUid(uid)) {
1529 return ActivityManager::PROCESS_STATE_TOP;
1530 }
1531 checkRegistered();
1532 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001533 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001534 // In an absense of the ActivityManager, assume everything to be active.
1535 if (!mObserverRegistered) {
1536 return ActivityManager::PROCESS_STATE_TOP;
1537 }
1538 auto cacheIter = mCachedUids.find(uid);
1539 if (cacheIter != mCachedUids.end()) {
1540 if (cacheIter->second.first) {
1541 return cacheIter->second.second;
1542 } else {
1543 return ActivityManager::PROCESS_STATE_UNKNOWN;
1544 }
1545 }
1546 }
1547 ActivityManager am;
Hui Yu12c7ec72020-05-04 17:40:52 +00001548 bool active = am.isUidActive(uid, String16("audioserver"));
Eric Laurente8c8b432018-10-17 10:08:02 -07001549 int state = ActivityManager::PROCESS_STATE_UNKNOWN;
1550 if (active) {
1551 state = am.getUidProcessState(uid, String16("audioserver"));
1552 }
1553 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001554 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001555 mCachedUids.insert(std::pair<uid_t,
1556 std::pair<bool, int>>(uid, std::pair<bool, int>(active, state)));
1557 }
Eric Laurent4eb58f12018-12-07 16:41:02 -08001558
Eric Laurente8c8b432018-10-17 10:08:02 -07001559 return state;
1560}
1561
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001562void AudioPolicyService::UidPolicy::onUidActive(uid_t uid) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001563 updateUid(&mCachedUids, uid, true, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001564}
1565
1566void AudioPolicyService::UidPolicy::onUidGone(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001567 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, false);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001568}
1569
1570void AudioPolicyService::UidPolicy::onUidIdle(uid_t uid, __unused bool disabled) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001571 updateUid(&mCachedUids, uid, false, ActivityManager::PROCESS_STATE_UNKNOWN, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001572}
1573
Eric Laurente8c8b432018-10-17 10:08:02 -07001574void AudioPolicyService::UidPolicy::onUidStateChanged(uid_t uid,
1575 int32_t procState,
Hui Yu13ad0eb2019-09-09 10:27:07 -07001576 int64_t procStateSeq __unused,
1577 int32_t capability __unused) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001578 if (procState != ActivityManager::PROCESS_STATE_UNKNOWN) {
1579 updateUid(&mCachedUids, uid, true, procState, true);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001580 }
1581}
1582
Austin Borgerdddb7552023-03-30 17:53:01 -07001583void AudioPolicyService::UidPolicy::onUidProcAdjChanged(uid_t uid __unused, int32_t adj __unused) {
Austin Borger65577682022-02-17 00:25:43 +00001584}
1585
Eric Laurente8c8b432018-10-17 10:08:02 -07001586void AudioPolicyService::UidPolicy::notifyService() {
1587 sp<AudioPolicyService> service = mService.promote();
1588 if (service != nullptr) {
1589 service->updateUidStates();
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001590 }
1591}
1592
Eric Laurente8c8b432018-10-17 10:08:02 -07001593void AudioPolicyService::UidPolicy::updateUid(std::unordered_map<uid_t,
1594 std::pair<bool, int>> *uids,
1595 uid_t uid,
1596 bool active,
1597 int state,
1598 bool insert) {
1599 if (isServiceUid(uid)) {
1600 return;
1601 }
1602 bool wasActive = isUidActive(uid);
1603 int previousState = getUidState(uid);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001604 {
Andy Hung79eacdb2023-11-30 19:34:24 -08001605 audio_utils::lock_guard _l(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -07001606 updateUidLocked(uids, uid, active, state, insert);
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001607 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001608 if (wasActive != isUidActive(uid) || state != previousState) {
1609 notifyService();
1610 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001611}
1612
Eric Laurente8c8b432018-10-17 10:08:02 -07001613void AudioPolicyService::UidPolicy::updateUidLocked(std::unordered_map<uid_t,
1614 std::pair<bool, int>> *uids,
1615 uid_t uid,
1616 bool active,
1617 int state,
1618 bool insert) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001619 auto it = uids->find(uid);
1620 if (it != uids->end()) {
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001621 if (insert) {
Eric Laurente8c8b432018-10-17 10:08:02 -07001622 if (state == ActivityManager::PROCESS_STATE_UNKNOWN) {
1623 it->second.first = active;
1624 }
1625 if (it->second.first) {
1626 it->second.second = state;
1627 } else {
1628 it->second.second = ActivityManager::PROCESS_STATE_UNKNOWN;
1629 }
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001630 } else {
1631 uids->erase(it);
1632 }
Eric Laurente8c8b432018-10-17 10:08:02 -07001633 } else if (insert && (state == ActivityManager::PROCESS_STATE_UNKNOWN)) {
1634 uids->insert(std::pair<uid_t, std::pair<bool, int>>(uid,
1635 std::pair<bool, int>(active, state)));
Mikhail Naganoveae73eb2018-04-03 16:57:36 -07001636 }
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001637}
Mathias Agopian65ab4712010-07-14 17:59:35 -07001638
Eric Laurent4eb58f12018-12-07 16:41:02 -08001639bool AudioPolicyService::UidPolicy::isA11yOnTop() {
Andy Hung79eacdb2023-11-30 19:34:24 -08001640 audio_utils::lock_guard _l(mMutex);
Eric Laurent4eb58f12018-12-07 16:41:02 -08001641 for (const auto &uid : mCachedUids) {
Eric Laurent47670c92019-08-28 16:59:05 -07001642 if (!isA11yUid(uid.first)) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001643 continue;
1644 }
Amith Yamasanibcbb3002019-01-23 13:53:33 -08001645 if (uid.second.second >= ActivityManager::PROCESS_STATE_TOP
1646 && uid.second.second <= ActivityManager::PROCESS_STATE_BOUND_FOREGROUND_SERVICE) {
Eric Laurent4eb58f12018-12-07 16:41:02 -08001647 return true;
1648 }
1649 }
1650 return false;
1651}
1652
Eric Laurentb78763e2018-10-17 10:08:02 -07001653bool AudioPolicyService::UidPolicy::isA11yUid(uid_t uid)
1654{
1655 std::vector<uid_t>::iterator it = find(mA11yUids.begin(), mA11yUids.end(), uid);
1656 return it != mA11yUids.end();
1657}
1658
Oscar Azucena829d90d2022-01-28 17:17:56 -08001659void AudioPolicyService::UidPolicy::setAssistantUids(const std::vector<uid_t>& uids) {
1660 mAssistantUids.clear();
1661 mAssistantUids = uids;
1662}
1663
1664bool AudioPolicyService::UidPolicy::isAssistantUid(uid_t uid)
1665{
1666 std::vector<uid_t>::iterator it = find(mAssistantUids.begin(), mAssistantUids.end(), uid);
1667 return it != mAssistantUids.end();
1668}
1669
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001670void AudioPolicyService::UidPolicy::setActiveAssistantUids(const std::vector<uid_t>& activeUids) {
1671 mActiveAssistantUids = activeUids;
1672}
1673
1674bool AudioPolicyService::UidPolicy::isActiveAssistantUid(uid_t uid)
1675{
1676 std::vector<uid_t>::iterator it = find(mActiveAssistantUids.begin(),
1677 mActiveAssistantUids.end(), uid);
1678 return it != mActiveAssistantUids.end();
1679}
1680
Oscar Azucena829d90d2022-01-28 17:17:56 -08001681void AudioPolicyService::UidPolicy::dumpInternals(int fd) {
1682 const size_t SIZE = 256;
1683 char buffer[SIZE];
1684 String8 result;
1685 auto appendUidsToResult = [&](const char* title, const std::vector<uid_t> &uids) {
1686 snprintf(buffer, SIZE, "\t%s: \n", title);
1687 result.append(buffer);
1688 int counter = 0;
1689 if (uids.empty()) {
1690 snprintf(buffer, SIZE, "\t\tNo UIDs present.\n");
1691 result.append(buffer);
1692 return;
1693 }
1694 for (const auto &uid : uids) {
1695 snprintf(buffer, SIZE, "\t\tUID[%d]=%d\n", counter++, uid);
1696 result.append(buffer);
1697 }
1698 };
1699
1700 snprintf(buffer, SIZE, "UID Policy:\n");
1701 result.append(buffer);
1702 snprintf(buffer, SIZE, "\tmObserverRegistered=%s\n",(mObserverRegistered ? "True":"False"));
1703 result.append(buffer);
1704
1705 appendUidsToResult("Assistants UIDs", mAssistantUids);
Oscar Azucenac2cdda32022-01-31 19:10:39 -08001706 appendUidsToResult("Active Assistants UIDs", mActiveAssistantUids);
Oscar Azucena829d90d2022-01-28 17:17:56 -08001707
1708 appendUidsToResult("Accessibility UIDs", mA11yUids);
1709
1710 snprintf(buffer, SIZE, "\tInput Method Service UID=%d\n", mCurrentImeUid);
1711 result.append(buffer);
1712
1713 snprintf(buffer, SIZE, "\tIs RTT Enabled: %s\n", (mRttEnabled ? "True":"False"));
1714 result.append(buffer);
1715
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001716 write(fd, result.c_str(), result.size());
Oscar Azucena829d90d2022-01-28 17:17:56 -08001717}
1718
Michael Groovercfd28302018-12-11 19:16:46 -08001719// ----------- AudioPolicyService::SensorPrivacyService implementation ----------
1720void AudioPolicyService::SensorPrivacyPolicy::registerSelf() {
1721 SensorPrivacyManager spm;
1722 mSensorPrivacyEnabled = spm.isSensorPrivacyEnabled();
1723 spm.addSensorPrivacyListener(this);
1724}
1725
1726void AudioPolicyService::SensorPrivacyPolicy::unregisterSelf() {
1727 SensorPrivacyManager spm;
1728 spm.removeSensorPrivacyListener(this);
1729}
1730
1731bool AudioPolicyService::SensorPrivacyPolicy::isSensorPrivacyEnabled() {
1732 return mSensorPrivacyEnabled;
1733}
1734
Evan Seversond8dc6832022-01-27 10:47:03 -08001735binder::Status AudioPolicyService::SensorPrivacyPolicy::onSensorPrivacyChanged(
1736 int toggleType __unused, int sensor __unused, bool enabled) {
Michael Groovercfd28302018-12-11 19:16:46 -08001737 mSensorPrivacyEnabled = enabled;
1738 sp<AudioPolicyService> service = mService.promote();
1739 if (service != nullptr) {
1740 service->updateUidStates();
1741 }
1742 return binder::Status::ok();
1743}
1744
Mathias Agopian65ab4712010-07-14 17:59:35 -07001745// ----------- AudioPolicyService::AudioCommandThread implementation ----------
1746
Eric Laurentbfb1b832013-01-07 09:53:42 -08001747AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name,
1748 const wp<AudioPolicyService>& service)
1749 : Thread(false), mName(name), mService(service)
Mathias Agopian65ab4712010-07-14 17:59:35 -07001750{
Mathias Agopian65ab4712010-07-14 17:59:35 -07001751}
1752
1753
1754AudioPolicyService::AudioCommandThread::~AudioCommandThread()
1755{
Eric Laurentbfb1b832013-01-07 09:53:42 -08001756 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001757 release_wake_lock(mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07001758 }
1759 mAudioCommands.clear();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001760}
1761
1762void AudioPolicyService::AudioCommandThread::onFirstRef()
1763{
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001764 run(mName.c_str(), ANDROID_PRIORITY_AUDIO);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001765}
1766
1767bool AudioPolicyService::AudioCommandThread::threadLoop()
1768{
Eric Laurentd7eda8d2016-02-02 17:18:39 -08001769 nsecs_t waitTime = -1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001770
Andy Hung79eacdb2023-11-30 19:34:24 -08001771 audio_utils::unique_lock ul(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07001772 while (!exitPending())
1773 {
Eric Laurent59a89232014-06-08 14:14:17 -07001774 sp<AudioPolicyService> svc;
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001775 int numTimesBecameEmpty = 0;
Eric Laurent59a89232014-06-08 14:14:17 -07001776 while (!mAudioCommands.isEmpty() && !exitPending()) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001777 nsecs_t curTime = systemTime();
1778 // commands are sorted by increasing time stamp: execute them from index 0 and up
1779 if (mAudioCommands[0]->mTime <= curTime) {
Eric Laurent0ede8922014-05-09 18:04:42 -07001780 sp<AudioCommand> command = mAudioCommands[0];
Mathias Agopian65ab4712010-07-14 17:59:35 -07001781 mAudioCommands.removeAt(0);
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07001782 if (mAudioCommands.isEmpty()) {
1783 ++numTimesBecameEmpty;
1784 }
Eric Laurent0ede8922014-05-09 18:04:42 -07001785 mLastCommand = command;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001786
1787 switch (command->mCommand) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07001788 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001789 VolumeData *data = (VolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001790 ALOGV("AudioCommandThread() processing set volume stream %d, \
Eric Laurentde070132010-07-13 04:45:46 -07001791 volume %f, output %d", data->mStream, data->mVolume, data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001792 ul.unlock();
Eric Laurentde070132010-07-13 04:45:46 -07001793 command->mStatus = AudioSystem::setStreamVolume(data->mStream,
1794 data->mVolume,
1795 data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001796 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001797 }break;
1798 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001799 ParametersData *data = (ParametersData *)command->mParam.get();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001800 ALOGV("AudioCommandThread() processing set parameters string %s, io %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001801 data->mKeyValuePairs.c_str(), data->mIO);
Andy Hung79eacdb2023-11-30 19:34:24 -08001802 ul.unlock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001803 command->mStatus = AudioSystem::setParameters(data->mIO, data->mKeyValuePairs);
Andy Hung79eacdb2023-11-30 19:34:24 -08001804 ul.lock();
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001805 }break;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001806 case SET_VOICE_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001807 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
Steve Block3856b092011-10-20 11:56:00 +01001808 ALOGV("AudioCommandThread() processing set voice volume volume %f",
Eric Laurentde070132010-07-13 04:45:46 -07001809 data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001810 ul.unlock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001811 command->mStatus = AudioSystem::setVoiceVolume(data->mVolume);
Andy Hung79eacdb2023-11-30 19:34:24 -08001812 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001813 }break;
Eric Laurentbfb1b832013-01-07 09:53:42 -08001814 case STOP_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001815 StopOutputData *data = (StopOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001816 ALOGV("AudioCommandThread() processing stop output portId %d",
1817 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001818 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001819 if (svc == 0) {
1820 break;
1821 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001822 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001823 svc->doStopOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001824 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001825 }break;
1826 case RELEASE_OUTPUT: {
Eric Laurent0ede8922014-05-09 18:04:42 -07001827 ReleaseOutputData *data = (ReleaseOutputData *)command->mParam.get();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001828 ALOGV("AudioCommandThread() processing release output portId %d",
1829 data->mPortId);
Eric Laurent59a89232014-06-08 14:14:17 -07001830 svc = mService.promote();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001831 if (svc == 0) {
1832 break;
1833 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001834 ul.unlock();
Eric Laurentd7fe0862018-07-14 16:48:01 -07001835 svc->doReleaseOutput(data->mPortId);
Andy Hung79eacdb2023-11-30 19:34:24 -08001836 ul.lock();
Eric Laurentbfb1b832013-01-07 09:53:42 -08001837 }break;
Eric Laurent951f4552014-05-20 10:48:17 -07001838 case CREATE_AUDIO_PATCH: {
1839 CreateAudioPatchData *data = (CreateAudioPatchData *)command->mParam.get();
1840 ALOGV("AudioCommandThread() processing create audio patch");
1841 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1842 if (af == 0) {
1843 command->mStatus = PERMISSION_DENIED;
1844 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001845 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001846 command->mStatus = af->createAudioPatch(&data->mPatch, &data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001847 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001848 }
1849 } break;
1850 case RELEASE_AUDIO_PATCH: {
1851 ReleaseAudioPatchData *data = (ReleaseAudioPatchData *)command->mParam.get();
1852 ALOGV("AudioCommandThread() processing release audio patch");
1853 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1854 if (af == 0) {
1855 command->mStatus = PERMISSION_DENIED;
1856 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001857 ul.unlock();
Eric Laurent951f4552014-05-20 10:48:17 -07001858 command->mStatus = af->releaseAudioPatch(data->mHandle);
Andy Hung79eacdb2023-11-30 19:34:24 -08001859 ul.lock();
Eric Laurent951f4552014-05-20 10:48:17 -07001860 }
1861 } break;
Eric Laurentb52c1522014-05-20 11:27:36 -07001862 case UPDATE_AUDIOPORT_LIST: {
1863 ALOGV("AudioCommandThread() processing update audio port list");
Eric Laurent59a89232014-06-08 14:14:17 -07001864 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001865 if (svc == 0) {
1866 break;
1867 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001868 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001869 svc->doOnAudioPortListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001870 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001871 }break;
1872 case UPDATE_AUDIOPATCH_LIST: {
1873 ALOGV("AudioCommandThread() processing update audio patch list");
Eric Laurent59a89232014-06-08 14:14:17 -07001874 svc = mService.promote();
Eric Laurentb52c1522014-05-20 11:27:36 -07001875 if (svc == 0) {
1876 break;
1877 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001878 ul.unlock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001879 svc->doOnAudioPatchListUpdate();
Andy Hung79eacdb2023-11-30 19:34:24 -08001880 ul.lock();
Eric Laurentb52c1522014-05-20 11:27:36 -07001881 }break;
François Gaffiecfe17322018-11-07 13:41:29 +01001882 case CHANGED_AUDIOVOLUMEGROUP: {
1883 AudioVolumeGroupData *data =
1884 static_cast<AudioVolumeGroupData *>(command->mParam.get());
1885 ALOGV("AudioCommandThread() processing update audio volume group");
1886 svc = mService.promote();
1887 if (svc == 0) {
1888 break;
1889 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001890 ul.unlock();
François Gaffiecfe17322018-11-07 13:41:29 +01001891 svc->doOnAudioVolumeGroupChanged(data->mGroup, data->mFlags);
Andy Hung79eacdb2023-11-30 19:34:24 -08001892 ul.lock();
François Gaffiecfe17322018-11-07 13:41:29 +01001893 }break;
Eric Laurente1715a42014-05-20 11:30:42 -07001894 case SET_AUDIOPORT_CONFIG: {
1895 SetAudioPortConfigData *data = (SetAudioPortConfigData *)command->mParam.get();
1896 ALOGV("AudioCommandThread() processing set port config");
1897 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1898 if (af == 0) {
1899 command->mStatus = PERMISSION_DENIED;
1900 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08001901 ul.unlock();
Eric Laurente1715a42014-05-20 11:30:42 -07001902 command->mStatus = af->setAudioPortConfig(&data->mConfig);
Andy Hung79eacdb2023-11-30 19:34:24 -08001903 ul.lock();
Eric Laurente1715a42014-05-20 11:30:42 -07001904 }
1905 } break;
Jean-Michel Trivide801052015-04-14 19:10:14 -07001906 case DYN_POLICY_MIX_STATE_UPDATE: {
1907 DynPolicyMixStateUpdateData *data =
1908 (DynPolicyMixStateUpdateData *)command->mParam.get();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001909 ALOGV("AudioCommandThread() processing dyn policy mix state update %s %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00001910 data->mRegId.c_str(), data->mState);
Jean-Michel Trivide801052015-04-14 19:10:14 -07001911 svc = mService.promote();
1912 if (svc == 0) {
1913 break;
1914 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001915 ul.unlock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001916 svc->doOnDynamicPolicyMixStateUpdate(data->mRegId, data->mState);
Andy Hung79eacdb2023-11-30 19:34:24 -08001917 ul.lock();
Jean-Michel Trivide801052015-04-14 19:10:14 -07001918 } break;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001919 case RECORDING_CONFIGURATION_UPDATE: {
1920 RecordingConfigurationUpdateData *data =
1921 (RecordingConfigurationUpdateData *)command->mParam.get();
1922 ALOGV("AudioCommandThread() processing recording configuration update");
1923 svc = mService.promote();
1924 if (svc == 0) {
1925 break;
1926 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001927 ul.unlock();
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08001928 svc->doOnRecordingConfigurationUpdate(data->mEvent, &data->mClientInfo,
Eric Laurenta9f86652018-11-28 17:23:11 -08001929 &data->mClientConfig, data->mClientEffects,
1930 &data->mDeviceConfig, data->mEffects,
1931 data->mPatchHandle, data->mSource);
Andy Hung79eacdb2023-11-30 19:34:24 -08001932 ul.lock();
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08001933 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001934 case SET_EFFECT_SUSPENDED: {
1935 SetEffectSuspendedData *data = (SetEffectSuspendedData *)command->mParam.get();
1936 ALOGV("AudioCommandThread() processing set effect suspended");
1937 sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
1938 if (af != 0) {
Andy Hung79eacdb2023-11-30 19:34:24 -08001939 ul.unlock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001940 af->setEffectSuspended(data->mEffectId, data->mSessionId, data->mSuspended);
Andy Hung79eacdb2023-11-30 19:34:24 -08001941 ul.lock();
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001942 }
1943 } break;
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001944 case AUDIO_MODULES_UPDATE: {
1945 ALOGV("AudioCommandThread() processing audio modules update");
1946 svc = mService.promote();
1947 if (svc == 0) {
1948 break;
1949 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001950 ul.unlock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001951 svc->doOnNewAudioModulesAvailable();
Andy Hung79eacdb2023-11-30 19:34:24 -08001952 ul.lock();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00001953 } break;
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001954 case ROUTING_UPDATED: {
1955 ALOGV("AudioCommandThread() processing routing update");
1956 svc = mService.promote();
1957 if (svc == 0) {
1958 break;
1959 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001960 ul.unlock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001961 svc->doOnRoutingUpdated();
Andy Hung79eacdb2023-11-30 19:34:24 -08001962 ul.lock();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07001963 } break;
Eric Laurentb20cf7d2019-04-05 19:37:34 -07001964
Eric Laurented726cc2021-07-01 14:26:41 +02001965 case UPDATE_UID_STATES: {
1966 ALOGV("AudioCommandThread() processing updateUID states");
1967 svc = mService.promote();
1968 if (svc == 0) {
1969 break;
1970 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001971 ul.unlock();
Eric Laurented726cc2021-07-01 14:26:41 +02001972 svc->updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -08001973 ul.lock();
Eric Laurented726cc2021-07-01 14:26:41 +02001974 } break;
1975
Eric Laurent15903592022-02-24 20:44:36 +01001976 case CHECK_SPATIALIZER_OUTPUT: {
1977 ALOGV("AudioCommandThread() processing check spatializer");
Eric Laurent81dd0f52021-07-05 11:54:40 +02001978 svc = mService.promote();
1979 if (svc == 0) {
1980 break;
1981 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001982 ul.unlock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02001983 svc->doOnCheckSpatializer();
Andy Hung79eacdb2023-11-30 19:34:24 -08001984 ul.lock();
Eric Laurent81dd0f52021-07-05 11:54:40 +02001985 } break;
1986
Eric Laurent15903592022-02-24 20:44:36 +01001987 case UPDATE_ACTIVE_SPATIALIZER_TRACKS: {
1988 ALOGV("AudioCommandThread() processing update spatializer tracks");
1989 svc = mService.promote();
1990 if (svc == 0) {
1991 break;
1992 }
Andy Hung79eacdb2023-11-30 19:34:24 -08001993 ul.unlock();
Eric Laurent15903592022-02-24 20:44:36 +01001994 svc->doOnUpdateActiveSpatializerTracks();
Andy Hung79eacdb2023-11-30 19:34:24 -08001995 ul.lock();
Eric Laurent15903592022-02-24 20:44:36 +01001996 } break;
1997
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00001998 case VOL_RANGE_INIT_REQUEST: {
1999 ALOGV("AudioCommandThread() processing volume range init request");
2000 svc = mService.promote();
2001 if (svc == 0) {
2002 break;
2003 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002004 ul.unlock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002005 svc->doOnVolumeRangeInitRequest();
Andy Hung79eacdb2023-11-30 19:34:24 -08002006 ul.lock();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002007 } break;
2008
Mathias Agopian65ab4712010-07-14 17:59:35 -07002009 default:
Steve Block5ff1dd52012-01-05 23:22:43 +00002010 ALOGW("AudioCommandThread() unknown command %d", command->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002011 }
Eric Laurent0ede8922014-05-09 18:04:42 -07002012 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002013 audio_utils::lock_guard _l(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002014 if (command->mWaitStatus) {
2015 command->mWaitStatus = false;
Andy Hung79eacdb2023-11-30 19:34:24 -08002016 command->mCond.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002017 }
2018 }
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002019 waitTime = -1;
Andy Hung79eacdb2023-11-30 19:34:24 -08002020 // release ul before releasing strong reference on the service as
Zach Janga754b4f2015-10-27 01:29:34 +00002021 // AudioPolicyService destructor calls AudioCommandThread::exit() which
Andy Hung79eacdb2023-11-30 19:34:24 -08002022 // acquires ul.
2023 ul.unlock();
Zach Janga754b4f2015-10-27 01:29:34 +00002024 svc.clear();
Andy Hung79eacdb2023-11-30 19:34:24 -08002025 ul.lock();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002026 } else {
2027 waitTime = mAudioCommands[0]->mTime - curTime;
2028 break;
2029 }
2030 }
Zach Janga754b4f2015-10-27 01:29:34 +00002031
Ytai Ben-Tsvi6958b022022-04-26 15:45:53 -07002032 // release delayed commands wake lock as many times as we made the queue is
2033 // empty during popping.
2034 while (numTimesBecameEmpty--) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002035 release_wake_lock(mName.c_str());
Zach Janga754b4f2015-10-27 01:29:34 +00002036 }
2037
2038 // At this stage we have either an empty command queue or the first command in the queue
2039 // has a finite delay. So unless we are exiting it is safe to wait.
2040 if (!exitPending()) {
Eric Laurent59a89232014-06-08 14:14:17 -07002041 ALOGV("AudioCommandThread() going to sleep");
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002042 if (waitTime == -1) {
Andy Hung79eacdb2023-11-30 19:34:24 -08002043 mWaitWorkCV.wait(ul);
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002044 } else {
Andy Hung79eacdb2023-11-30 19:34:24 -08002045 // discard return value.
2046 mWaitWorkCV.wait_for(ul, std::chrono::nanoseconds(waitTime));
Eric Laurentd7eda8d2016-02-02 17:18:39 -08002047 }
Eric Laurent59a89232014-06-08 14:14:17 -07002048 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002049 }
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002050 // release delayed commands wake lock before quitting
2051 if (!mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002052 release_wake_lock(mName.c_str());
Ricardo Garcia05f2fdc2014-07-24 15:48:24 -07002053 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002054 return false;
2055}
2056
2057status_t AudioPolicyService::AudioCommandThread::dump(int fd)
Andy Hung79eacdb2023-11-30 19:34:24 -08002058NO_THREAD_SAFETY_ANALYSIS // trylock
Mathias Agopian65ab4712010-07-14 17:59:35 -07002059{
2060 const size_t SIZE = 256;
2061 char buffer[SIZE];
2062 String8 result;
2063
Andy Hung79eacdb2023-11-30 19:34:24 -08002064 const bool locked = mMutex.try_lock(kDumpLockTimeoutNs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002065 if (!locked) {
2066 String8 result2(kCmdDeadlockedString);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002067 write(fd, result2.c_str(), result2.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002068 }
2069
2070 snprintf(buffer, SIZE, "- Commands:\n");
2071 result = String8(buffer);
2072 result.append(" Command Time Wait pParam\n");
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002073 for (size_t i = 0; i < mAudioCommands.size(); i++) {
Mathias Agopian65ab4712010-07-14 17:59:35 -07002074 mAudioCommands[i]->dump(buffer, SIZE);
2075 result.append(buffer);
2076 }
2077 result.append(" Last Command\n");
Eric Laurent0ede8922014-05-09 18:04:42 -07002078 if (mLastCommand != 0) {
2079 mLastCommand->dump(buffer, SIZE);
2080 result.append(buffer);
2081 } else {
2082 result.append(" none\n");
2083 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002084
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002085 write(fd, result.c_str(), result.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002086
Andy Hung79eacdb2023-11-30 19:34:24 -08002087 dumpReleaseLock(mMutex, locked);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002088
2089 return NO_ERROR;
2090}
2091
Glenn Kastenfff6d712012-01-12 16:38:12 -08002092status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -07002093 float volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002094 audio_io_handle_t output,
Eric Laurentde070132010-07-13 04:45:46 -07002095 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002096{
Eric Laurent0ede8922014-05-09 18:04:42 -07002097 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002098 command->mCommand = SET_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002099 sp<VolumeData> data = new VolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002100 data->mStream = stream;
2101 data->mVolume = volume;
2102 data->mIO = output;
2103 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002104 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002105 ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",
Eric Laurentde070132010-07-13 04:45:46 -07002106 stream, volume, output);
Eric Laurent0ede8922014-05-09 18:04:42 -07002107 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002108}
2109
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002110status_t AudioPolicyService::AudioCommandThread::parametersCommand(audio_io_handle_t ioHandle,
Dima Zavinfce7a472011-04-19 22:30:36 -07002111 const char *keyValuePairs,
Eric Laurentde070132010-07-13 04:45:46 -07002112 int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002113{
Eric Laurent0ede8922014-05-09 18:04:42 -07002114 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002115 command->mCommand = SET_PARAMETERS;
Eric Laurent0ede8922014-05-09 18:04:42 -07002116 sp<ParametersData> data = new ParametersData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002117 data->mIO = ioHandle;
Dima Zavinfce7a472011-04-19 22:30:36 -07002118 data->mKeyValuePairs = String8(keyValuePairs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002119 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002120 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002121 ALOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d",
Dima Zavinfce7a472011-04-19 22:30:36 -07002122 keyValuePairs, ioHandle, delayMs);
Eric Laurent0ede8922014-05-09 18:04:42 -07002123 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002124}
2125
2126status_t AudioPolicyService::AudioCommandThread::voiceVolumeCommand(float volume, int delayMs)
2127{
Eric Laurent0ede8922014-05-09 18:04:42 -07002128 sp<AudioCommand> command = new AudioCommand();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002129 command->mCommand = SET_VOICE_VOLUME;
Eric Laurent0ede8922014-05-09 18:04:42 -07002130 sp<VoiceVolumeData> data = new VoiceVolumeData();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002131 data->mVolume = volume;
2132 command->mParam = data;
Eric Laurent0ede8922014-05-09 18:04:42 -07002133 command->mWaitStatus = true;
Steve Block3856b092011-10-20 11:56:00 +01002134 ALOGV("AudioCommandThread() adding set voice volume volume %f", volume);
Eric Laurent0ede8922014-05-09 18:04:42 -07002135 return sendCommand(command, delayMs);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002136}
2137
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002138void AudioPolicyService::AudioCommandThread::setEffectSuspendedCommand(int effectId,
2139 audio_session_t sessionId,
2140 bool suspended)
2141{
2142 sp<AudioCommand> command = new AudioCommand();
2143 command->mCommand = SET_EFFECT_SUSPENDED;
2144 sp<SetEffectSuspendedData> data = new SetEffectSuspendedData();
2145 data->mEffectId = effectId;
2146 data->mSessionId = sessionId;
2147 data->mSuspended = suspended;
2148 command->mParam = data;
2149 ALOGV("AudioCommandThread() adding set suspended effectId %d sessionId %d suspended %d",
2150 effectId, sessionId, suspended);
2151 sendCommand(command);
2152}
2153
2154
Eric Laurentd7fe0862018-07-14 16:48:01 -07002155void AudioPolicyService::AudioCommandThread::stopOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002156{
Eric Laurent0ede8922014-05-09 18:04:42 -07002157 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002158 command->mCommand = STOP_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002159 sp<StopOutputData> data = new StopOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002160 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002161 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002162 ALOGV("AudioCommandThread() adding stop output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002163 sendCommand(command);
Eric Laurentbfb1b832013-01-07 09:53:42 -08002164}
2165
Eric Laurentd7fe0862018-07-14 16:48:01 -07002166void AudioPolicyService::AudioCommandThread::releaseOutputCommand(audio_port_handle_t portId)
Eric Laurentbfb1b832013-01-07 09:53:42 -08002167{
Eric Laurent0ede8922014-05-09 18:04:42 -07002168 sp<AudioCommand> command = new AudioCommand();
Eric Laurentbfb1b832013-01-07 09:53:42 -08002169 command->mCommand = RELEASE_OUTPUT;
Eric Laurent0ede8922014-05-09 18:04:42 -07002170 sp<ReleaseOutputData> data = new ReleaseOutputData();
Eric Laurentd7fe0862018-07-14 16:48:01 -07002171 data->mPortId = portId;
Jesper Tragardh48412dc2014-03-24 14:12:43 +01002172 command->mParam = data;
Eric Laurentd7fe0862018-07-14 16:48:01 -07002173 ALOGV("AudioCommandThread() adding release output portId %d", portId);
Eric Laurent0ede8922014-05-09 18:04:42 -07002174 sendCommand(command);
2175}
2176
Eric Laurent951f4552014-05-20 10:48:17 -07002177status_t AudioPolicyService::AudioCommandThread::createAudioPatchCommand(
2178 const struct audio_patch *patch,
2179 audio_patch_handle_t *handle,
2180 int delayMs)
2181{
2182 status_t status = NO_ERROR;
2183
2184 sp<AudioCommand> command = new AudioCommand();
2185 command->mCommand = CREATE_AUDIO_PATCH;
2186 CreateAudioPatchData *data = new CreateAudioPatchData();
2187 data->mPatch = *patch;
2188 data->mHandle = *handle;
2189 command->mParam = data;
2190 command->mWaitStatus = true;
2191 ALOGV("AudioCommandThread() adding create patch delay %d", delayMs);
2192 status = sendCommand(command, delayMs);
2193 if (status == NO_ERROR) {
2194 *handle = data->mHandle;
2195 }
2196 return status;
2197}
2198
2199status_t AudioPolicyService::AudioCommandThread::releaseAudioPatchCommand(audio_patch_handle_t handle,
2200 int delayMs)
2201{
2202 sp<AudioCommand> command = new AudioCommand();
2203 command->mCommand = RELEASE_AUDIO_PATCH;
2204 ReleaseAudioPatchData *data = new ReleaseAudioPatchData();
2205 data->mHandle = handle;
2206 command->mParam = data;
2207 command->mWaitStatus = true;
2208 ALOGV("AudioCommandThread() adding release patch delay %d", delayMs);
2209 return sendCommand(command, delayMs);
2210}
2211
Eric Laurentb52c1522014-05-20 11:27:36 -07002212void AudioPolicyService::AudioCommandThread::updateAudioPortListCommand()
2213{
2214 sp<AudioCommand> command = new AudioCommand();
2215 command->mCommand = UPDATE_AUDIOPORT_LIST;
2216 ALOGV("AudioCommandThread() adding update audio port list");
2217 sendCommand(command);
2218}
2219
Eric Laurented726cc2021-07-01 14:26:41 +02002220void AudioPolicyService::AudioCommandThread::updateUidStatesCommand()
2221{
2222 sp<AudioCommand> command = new AudioCommand();
2223 command->mCommand = UPDATE_UID_STATES;
2224 ALOGV("AudioCommandThread() adding update UID states");
2225 sendCommand(command);
2226}
2227
Eric Laurentb52c1522014-05-20 11:27:36 -07002228void AudioPolicyService::AudioCommandThread::updateAudioPatchListCommand()
2229{
2230 sp<AudioCommand>command = new AudioCommand();
2231 command->mCommand = UPDATE_AUDIOPATCH_LIST;
2232 ALOGV("AudioCommandThread() adding update audio patch list");
2233 sendCommand(command);
2234}
2235
François Gaffiecfe17322018-11-07 13:41:29 +01002236void AudioPolicyService::AudioCommandThread::changeAudioVolumeGroupCommand(volume_group_t group,
2237 int flags)
2238{
2239 sp<AudioCommand>command = new AudioCommand();
2240 command->mCommand = CHANGED_AUDIOVOLUMEGROUP;
2241 AudioVolumeGroupData *data= new AudioVolumeGroupData();
2242 data->mGroup = group;
2243 data->mFlags = flags;
2244 command->mParam = data;
2245 ALOGV("AudioCommandThread() adding audio volume group changed");
2246 sendCommand(command);
2247}
2248
Eric Laurente1715a42014-05-20 11:30:42 -07002249status_t AudioPolicyService::AudioCommandThread::setAudioPortConfigCommand(
2250 const struct audio_port_config *config, int delayMs)
2251{
2252 sp<AudioCommand> command = new AudioCommand();
2253 command->mCommand = SET_AUDIOPORT_CONFIG;
2254 SetAudioPortConfigData *data = new SetAudioPortConfigData();
2255 data->mConfig = *config;
2256 command->mParam = data;
2257 command->mWaitStatus = true;
2258 ALOGV("AudioCommandThread() adding set port config delay %d", delayMs);
2259 return sendCommand(command, delayMs);
2260}
2261
Jean-Michel Trivide801052015-04-14 19:10:14 -07002262void AudioPolicyService::AudioCommandThread::dynamicPolicyMixStateUpdateCommand(
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -07002263 const String8& regId, int32_t state)
Jean-Michel Trivide801052015-04-14 19:10:14 -07002264{
2265 sp<AudioCommand> command = new AudioCommand();
2266 command->mCommand = DYN_POLICY_MIX_STATE_UPDATE;
2267 DynPolicyMixStateUpdateData *data = new DynPolicyMixStateUpdateData();
2268 data->mRegId = regId;
2269 data->mState = state;
2270 command->mParam = data;
2271 ALOGV("AudioCommandThread() sending dynamic policy mix (id=%s) state update to %d",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002272 regId.c_str(), state);
Jean-Michel Trivide801052015-04-14 19:10:14 -07002273 sendCommand(command);
2274}
2275
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002276void AudioPolicyService::AudioCommandThread::recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -08002277 int event,
2278 const record_client_info_t *clientInfo,
2279 const audio_config_base_t *clientConfig,
2280 std::vector<effect_descriptor_t> clientEffects,
2281 const audio_config_base_t *deviceConfig,
2282 std::vector<effect_descriptor_t> effects,
2283 audio_patch_handle_t patchHandle,
2284 audio_source_t source)
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002285{
2286 sp<AudioCommand>command = new AudioCommand();
2287 command->mCommand = RECORDING_CONFIGURATION_UPDATE;
2288 RecordingConfigurationUpdateData *data = new RecordingConfigurationUpdateData();
2289 data->mEvent = event;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002290 data->mClientInfo = *clientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002291 data->mClientConfig = *clientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002292 data->mClientEffects = clientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -08002293 data->mDeviceConfig = *deviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -08002294 data->mEffects = effects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -08002295 data->mPatchHandle = patchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -08002296 data->mSource = source;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002297 command->mParam = data;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -08002298 ALOGV("AudioCommandThread() adding recording configuration update event %d, source %d uid %u",
2299 event, clientInfo->source, clientInfo->uid);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002300 sendCommand(command);
2301}
2302
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002303void AudioPolicyService::AudioCommandThread::audioModulesUpdateCommand()
2304{
2305 sp<AudioCommand> command = new AudioCommand();
2306 command->mCommand = AUDIO_MODULES_UPDATE;
2307 sendCommand(command);
2308}
2309
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002310void AudioPolicyService::AudioCommandThread::routingChangedCommand()
2311{
2312 sp<AudioCommand>command = new AudioCommand();
2313 command->mCommand = ROUTING_UPDATED;
2314 ALOGV("AudioCommandThread() adding routing update");
2315 sendCommand(command);
2316}
2317
Eric Laurent81dd0f52021-07-05 11:54:40 +02002318void AudioPolicyService::AudioCommandThread::checkSpatializerCommand()
2319{
2320 sp<AudioCommand>command = new AudioCommand();
Eric Laurent15903592022-02-24 20:44:36 +01002321 command->mCommand = CHECK_SPATIALIZER_OUTPUT;
Eric Laurent81dd0f52021-07-05 11:54:40 +02002322 ALOGV("AudioCommandThread() adding check spatializer");
2323 sendCommand(command);
2324}
2325
Eric Laurent15903592022-02-24 20:44:36 +01002326void AudioPolicyService::AudioCommandThread::updateActiveSpatializerTracksCommand()
2327{
2328 sp<AudioCommand>command = new AudioCommand();
2329 command->mCommand = UPDATE_ACTIVE_SPATIALIZER_TRACKS;
2330 ALOGV("AudioCommandThread() adding update active spatializer tracks");
2331 sendCommand(command);
2332}
2333
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002334void AudioPolicyService::AudioCommandThread::volRangeInitReqCommand()
2335{
2336 sp<AudioCommand>command = new AudioCommand();
2337 command->mCommand = VOL_RANGE_INIT_REQUEST;
2338 ALOGV("AudioCommandThread() adding volume range init request");
2339 sendCommand(command);
2340}
2341
Eric Laurent0ede8922014-05-09 18:04:42 -07002342status_t AudioPolicyService::AudioCommandThread::sendCommand(sp<AudioCommand>& command, int delayMs)
2343{
2344 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002345 audio_utils::lock_guard _l(mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002346 insertCommand_l(command, delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002347 mWaitWorkCV.notify_one();
Eric Laurent0ede8922014-05-09 18:04:42 -07002348 }
Andy Hung79eacdb2023-11-30 19:34:24 -08002349 audio_utils::unique_lock ul(command->mMutex);
Eric Laurent0ede8922014-05-09 18:04:42 -07002350 while (command->mWaitStatus) {
2351 nsecs_t timeOutNs = kAudioCommandTimeoutNs + milliseconds(delayMs);
Andy Hung79eacdb2023-11-30 19:34:24 -08002352 if (command->mCond.wait_for(
Andy Hung02ea2a02024-01-25 17:02:30 -08002353 ul, std::chrono::nanoseconds(timeOutNs), getTid()) == std::cv_status::timeout) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002354 command->mStatus = TIMED_OUT;
2355 command->mWaitStatus = false;
2356 }
2357 }
2358 return command->mStatus;
Eric Laurentbfb1b832013-01-07 09:53:42 -08002359}
2360
Andy Hung79eacdb2023-11-30 19:34:24 -08002361// insertCommand_l() must be called with mMutex held
Eric Laurent0ede8922014-05-09 18:04:42 -07002362void AudioPolicyService::AudioCommandThread::insertCommand_l(sp<AudioCommand>& command, int delayMs)
Mathias Agopian65ab4712010-07-14 17:59:35 -07002363{
Glenn Kasten8d6a2442012-02-08 14:04:28 -08002364 ssize_t i; // not size_t because i will count down to -1
Eric Laurent0ede8922014-05-09 18:04:42 -07002365 Vector < sp<AudioCommand> > removedCommands;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002366 command->mTime = systemTime() + milliseconds(delayMs);
2367
2368 // acquire wake lock to make sure delayed commands are processed
Eric Laurentbfb1b832013-01-07 09:53:42 -08002369 if (mAudioCommands.isEmpty()) {
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002370 acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002371 }
2372
2373 // check same pending commands with later time stamps and eliminate them
Ivan Lozano5ff158f2017-10-30 09:06:24 -07002374 for (i = (ssize_t)mAudioCommands.size()-1; i >= 0; i--) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002375 sp<AudioCommand> command2 = mAudioCommands[i];
Mathias Agopian65ab4712010-07-14 17:59:35 -07002376 // commands are sorted by increasing time stamp: no need to scan the rest of mAudioCommands
2377 if (command2->mTime <= command->mTime) break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002378
2379 // create audio patch or release audio patch commands are equivalent
2380 // with regard to filtering
2381 if ((command->mCommand == CREATE_AUDIO_PATCH) ||
2382 (command->mCommand == RELEASE_AUDIO_PATCH)) {
2383 if ((command2->mCommand != CREATE_AUDIO_PATCH) &&
2384 (command2->mCommand != RELEASE_AUDIO_PATCH)) {
2385 continue;
2386 }
2387 } else if (command2->mCommand != command->mCommand) continue;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002388
2389 switch (command->mCommand) {
2390 case SET_PARAMETERS: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002391 ParametersData *data = (ParametersData *)command->mParam.get();
2392 ParametersData *data2 = (ParametersData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002393 if (data->mIO != data2->mIO) break;
Steve Block3856b092011-10-20 11:56:00 +01002394 ALOGV("Comparing parameter command %s to new command %s",
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002395 data2->mKeyValuePairs.c_str(), data->mKeyValuePairs.c_str());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002396 AudioParameter param = AudioParameter(data->mKeyValuePairs);
2397 AudioParameter param2 = AudioParameter(data2->mKeyValuePairs);
2398 for (size_t j = 0; j < param.size(); j++) {
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002399 String8 key;
2400 String8 value;
2401 param.getAt(j, key, value);
2402 for (size_t k = 0; k < param2.size(); k++) {
2403 String8 key2;
2404 String8 value2;
2405 param2.getAt(k, key2, value2);
2406 if (key2 == key) {
2407 param2.remove(key2);
Tomasz Wasilczyk833345b2023-08-15 20:59:35 +00002408 ALOGV("Filtering out parameter %s", key2.c_str());
Glenn Kastene53b9ea2012-03-12 16:29:55 -07002409 break;
2410 }
2411 }
Mathias Agopian65ab4712010-07-14 17:59:35 -07002412 }
2413 // if all keys have been filtered out, remove the command.
2414 // otherwise, update the key value pairs
2415 if (param2.size() == 0) {
2416 removedCommands.add(command2);
2417 } else {
2418 data2->mKeyValuePairs = param2.toString();
2419 }
Eric Laurent21e54562013-09-23 12:08:05 -07002420 command->mTime = command2->mTime;
2421 // force delayMs to non 0 so that code below does not request to wait for
2422 // command status as the command is now delayed
2423 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002424 } break;
2425
2426 case SET_VOLUME: {
Eric Laurent0ede8922014-05-09 18:04:42 -07002427 VolumeData *data = (VolumeData *)command->mParam.get();
2428 VolumeData *data2 = (VolumeData *)command2->mParam.get();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002429 if (data->mIO != data2->mIO) break;
2430 if (data->mStream != data2->mStream) break;
Steve Block3856b092011-10-20 11:56:00 +01002431 ALOGV("Filtering out volume command on output %d for stream %d",
Eric Laurentde070132010-07-13 04:45:46 -07002432 data->mIO, data->mStream);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002433 removedCommands.add(command2);
Eric Laurent21e54562013-09-23 12:08:05 -07002434 command->mTime = command2->mTime;
2435 // force delayMs to non 0 so that code below does not request to wait for
2436 // command status as the command is now delayed
2437 delayMs = 1;
Mathias Agopian65ab4712010-07-14 17:59:35 -07002438 } break;
Eric Laurente45b48a2014-09-04 16:40:57 -07002439
Eric Laurentbaf35fe2016-07-27 15:36:53 -07002440 case SET_VOICE_VOLUME: {
2441 VoiceVolumeData *data = (VoiceVolumeData *)command->mParam.get();
2442 VoiceVolumeData *data2 = (VoiceVolumeData *)command2->mParam.get();
2443 ALOGV("Filtering out voice volume command value %f replaced by %f",
2444 data2->mVolume, data->mVolume);
2445 removedCommands.add(command2);
2446 command->mTime = command2->mTime;
2447 // force delayMs to non 0 so that code below does not request to wait for
2448 // command status as the command is now delayed
2449 delayMs = 1;
2450 } break;
2451
Eric Laurente45b48a2014-09-04 16:40:57 -07002452 case CREATE_AUDIO_PATCH:
2453 case RELEASE_AUDIO_PATCH: {
2454 audio_patch_handle_t handle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002455 struct audio_patch patch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002456 if (command->mCommand == CREATE_AUDIO_PATCH) {
2457 handle = ((CreateAudioPatchData *)command->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002458 patch = ((CreateAudioPatchData *)command->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002459 } else {
2460 handle = ((ReleaseAudioPatchData *)command->mParam.get())->mHandle;
Mikhail Naganov7be71d22018-05-23 16:51:46 -07002461 memset(&patch, 0, sizeof(patch));
Eric Laurente45b48a2014-09-04 16:40:57 -07002462 }
2463 audio_patch_handle_t handle2;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002464 struct audio_patch patch2;
Eric Laurente45b48a2014-09-04 16:40:57 -07002465 if (command2->mCommand == CREATE_AUDIO_PATCH) {
2466 handle2 = ((CreateAudioPatchData *)command2->mParam.get())->mHandle;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002467 patch2 = ((CreateAudioPatchData *)command2->mParam.get())->mPatch;
Eric Laurente45b48a2014-09-04 16:40:57 -07002468 } else {
2469 handle2 = ((ReleaseAudioPatchData *)command2->mParam.get())->mHandle;
Glenn Kastenf60b6b62015-07-06 10:53:26 -07002470 memset(&patch2, 0, sizeof(patch2));
Eric Laurente45b48a2014-09-04 16:40:57 -07002471 }
2472 if (handle != handle2) break;
Haynes Mathew Georgea2d4a6d2014-10-13 13:05:22 -07002473 /* Filter CREATE_AUDIO_PATCH commands only when they are issued for
2474 same output. */
2475 if( (command->mCommand == CREATE_AUDIO_PATCH) &&
2476 (command2->mCommand == CREATE_AUDIO_PATCH) ) {
2477 bool isOutputDiff = false;
2478 if (patch.num_sources == patch2.num_sources) {
2479 for (unsigned count = 0; count < patch.num_sources; count++) {
2480 if (patch.sources[count].id != patch2.sources[count].id) {
2481 isOutputDiff = true;
2482 break;
2483 }
2484 }
2485 if (isOutputDiff)
2486 break;
2487 }
2488 }
Eric Laurente45b48a2014-09-04 16:40:57 -07002489 ALOGV("Filtering out %s audio patch command for handle %d",
2490 (command->mCommand == CREATE_AUDIO_PATCH) ? "create" : "release", handle);
2491 removedCommands.add(command2);
2492 command->mTime = command2->mTime;
2493 // force delayMs to non 0 so that code below does not request to wait for
2494 // command status as the command is now delayed
2495 delayMs = 1;
2496 } break;
2497
Jean-Michel Trivide801052015-04-14 19:10:14 -07002498 case DYN_POLICY_MIX_STATE_UPDATE: {
2499
2500 } break;
2501
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -08002502 case RECORDING_CONFIGURATION_UPDATE: {
2503
2504 } break;
2505
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -07002506 case ROUTING_UPDATED: {
2507
2508 } break;
2509
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +00002510 case VOL_RANGE_INIT_REQUEST: {
2511 // command may come from different requests, do not filter
2512 } break;
2513
Mathias Agopian65ab4712010-07-14 17:59:35 -07002514 default:
2515 break;
2516 }
2517 }
2518
2519 // remove filtered commands
2520 for (size_t j = 0; j < removedCommands.size(); j++) {
2521 // removed commands always have time stamps greater than current command
2522 for (size_t k = i + 1; k < mAudioCommands.size(); k++) {
Eric Laurent0ede8922014-05-09 18:04:42 -07002523 if (mAudioCommands[k].get() == removedCommands[j].get()) {
Steve Block3856b092011-10-20 11:56:00 +01002524 ALOGV("suppressing command: %d", mAudioCommands[k]->mCommand);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002525 mAudioCommands.removeAt(k);
2526 break;
2527 }
2528 }
2529 }
2530 removedCommands.clear();
2531
Eric Laurentaa79bef2015-01-15 14:33:51 -08002532 // Disable wait for status if delay is not 0.
2533 // Except for create audio patch command because the returned patch handle
2534 // is needed by audio policy manager
2535 if (delayMs != 0 && command->mCommand != CREATE_AUDIO_PATCH) {
Eric Laurentcec4abb2012-07-03 12:23:02 -07002536 command->mWaitStatus = false;
2537 }
Eric Laurentcec4abb2012-07-03 12:23:02 -07002538
Mathias Agopian65ab4712010-07-14 17:59:35 -07002539 // insert command at the right place according to its time stamp
Eric Laurent1e693b52014-07-09 15:03:28 -07002540 ALOGV("inserting command: %d at index %zd, num commands %zu",
2541 command->mCommand, i+1, mAudioCommands.size());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002542 mAudioCommands.insertAt(command, i + 1);
2543}
2544
2545void AudioPolicyService::AudioCommandThread::exit()
2546{
Steve Block3856b092011-10-20 11:56:00 +01002547 ALOGV("AudioCommandThread::exit");
Mathias Agopian65ab4712010-07-14 17:59:35 -07002548 {
Andy Hung79eacdb2023-11-30 19:34:24 -08002549 audio_utils::lock_guard _l(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -07002550 requestExit();
Andy Hung79eacdb2023-11-30 19:34:24 -08002551 mWaitWorkCV.notify_one();
Mathias Agopian65ab4712010-07-14 17:59:35 -07002552 }
Zach Janga754b4f2015-10-27 01:29:34 +00002553 // Note that we can call it from the thread loop if all other references have been released
2554 // but it will safely return WOULD_BLOCK in this case
Mathias Agopian65ab4712010-07-14 17:59:35 -07002555 requestExitAndWait();
2556}
2557
2558void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, size_t size)
2559{
2560 snprintf(buffer, size, " %02d %06d.%03d %01u %p\n",
2561 mCommand,
2562 (int)ns2s(mTime),
2563 (int)ns2ms(mTime)%1000,
2564 mWaitStatus,
Eric Laurent0ede8922014-05-09 18:04:42 -07002565 mParam.get());
Mathias Agopian65ab4712010-07-14 17:59:35 -07002566}
2567
Dima Zavinfce7a472011-04-19 22:30:36 -07002568/******* helpers for the service_ops callbacks defined below *********/
2569void AudioPolicyService::setParameters(audio_io_handle_t ioHandle,
2570 const char *keyValuePairs,
2571 int delayMs)
2572{
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002573 mAudioCommandThread->parametersCommand(ioHandle, keyValuePairs,
Dima Zavinfce7a472011-04-19 22:30:36 -07002574 delayMs);
2575}
2576
2577int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,
2578 float volume,
2579 audio_io_handle_t output,
2580 int delayMs)
2581{
Glenn Kastenfff6d712012-01-12 16:38:12 -08002582 return (int)mAudioCommandThread->volumeCommand(stream, volume,
Glenn Kasten72ef00d2012-01-17 11:09:42 -08002583 output, delayMs);
Dima Zavinfce7a472011-04-19 22:30:36 -07002584}
2585
Dima Zavinfce7a472011-04-19 22:30:36 -07002586int AudioPolicyService::setVoiceVolume(float volume, int delayMs)
2587{
2588 return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs);
2589}
2590
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002591void AudioPolicyService::setEffectSuspended(int effectId,
2592 audio_session_t sessionId,
2593 bool suspended)
2594{
2595 mAudioCommandThread->setEffectSuspendedCommand(effectId, sessionId, suspended);
2596}
2597
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002598Status AudioPolicyService::onNewAudioModulesAvailable()
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002599{
Mikhail Naganovd0e2c742020-03-25 15:59:59 -07002600 mOutputCommandThread->audioModulesUpdateCommand();
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -08002601 return Status::ok();
Mikhail Naganov88b30d22020-03-09 19:43:13 +00002602}
2603
Eric Laurentb20cf7d2019-04-05 19:37:34 -07002604
Dima Zavinfce7a472011-04-19 22:30:36 -07002605extern "C" {
Eric Laurent2d388ec2014-03-07 13:25:54 -08002606audio_module_handle_t aps_load_hw_module(void *service __unused,
2607 const char *name);
2608audio_io_handle_t aps_open_output(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002609 audio_devices_t *pDevices,
2610 uint32_t *pSamplingRate,
2611 audio_format_t *pFormat,
2612 audio_channel_mask_t *pChannelMask,
2613 uint32_t *pLatencyMs,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002614 audio_output_flags_t flags);
Eric Laurenta4c5a552012-03-29 10:12:40 -07002615
Eric Laurent2d388ec2014-03-07 13:25:54 -08002616audio_io_handle_t aps_open_output_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002617 audio_module_handle_t module,
2618 audio_devices_t *pDevices,
2619 uint32_t *pSamplingRate,
2620 audio_format_t *pFormat,
2621 audio_channel_mask_t *pChannelMask,
2622 uint32_t *pLatencyMs,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002623 audio_output_flags_t flags,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002624 const audio_offload_info_t *offloadInfo);
2625audio_io_handle_t aps_open_dup_output(void *service __unused,
Dima Zavinfce7a472011-04-19 22:30:36 -07002626 audio_io_handle_t output1,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002627 audio_io_handle_t output2);
2628int aps_close_output(void *service __unused, audio_io_handle_t output);
2629int aps_suspend_output(void *service __unused, audio_io_handle_t output);
2630int aps_restore_output(void *service __unused, audio_io_handle_t output);
2631audio_io_handle_t aps_open_input(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002632 audio_devices_t *pDevices,
2633 uint32_t *pSamplingRate,
2634 audio_format_t *pFormat,
2635 audio_channel_mask_t *pChannelMask,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002636 audio_in_acoustics_t acoustics __unused);
2637audio_io_handle_t aps_open_input_on_module(void *service __unused,
Eric Laurenta4c5a552012-03-29 10:12:40 -07002638 audio_module_handle_t module,
2639 audio_devices_t *pDevices,
2640 uint32_t *pSamplingRate,
2641 audio_format_t *pFormat,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002642 audio_channel_mask_t *pChannelMask);
2643int aps_close_input(void *service __unused, audio_io_handle_t input);
2644int aps_invalidate_stream(void *service __unused, audio_stream_type_t stream);
Glenn Kastend848eb42016-03-08 13:42:11 -08002645int aps_move_effects(void *service __unused, audio_session_t session,
Dima Zavinfce7a472011-04-19 22:30:36 -07002646 audio_io_handle_t src_output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002647 audio_io_handle_t dst_output);
2648char * aps_get_parameters(void *service __unused, audio_io_handle_t io_handle,
2649 const char *keys);
2650void aps_set_parameters(void *service, audio_io_handle_t io_handle,
2651 const char *kv_pairs, int delay_ms);
2652int aps_set_stream_volume(void *service, audio_stream_type_t stream,
Dima Zavinfce7a472011-04-19 22:30:36 -07002653 float volume, audio_io_handle_t output,
Eric Laurent2d388ec2014-03-07 13:25:54 -08002654 int delay_ms);
Eric Laurent2d388ec2014-03-07 13:25:54 -08002655int aps_set_voice_volume(void *service, float volume, int delay_ms);
2656};
Dima Zavinfce7a472011-04-19 22:30:36 -07002657
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08002658} // namespace android