blob: abc1dca9283ecfd2c35758afd1451a2e221ee521 [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#ifndef ANDROID_AUDIOPOLICYSERVICE_H
18#define ANDROID_AUDIOPOLICYSERVICE_H
19
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080020#include <android/media/BnAudioPolicyService.h>
Eric Laurent81dd0f52021-07-05 11:54:40 +020021#include <android/media/GetSpatializerResponse.h>
Mikhail Naganov197d50a2020-04-30 22:37:43 +000022#include <android-base/thread_annotations.h>
Andy Hung79eacdb2023-11-30 19:34:24 -080023#include <audio_utils/mutex.h>
Atneya Nair9f91a5e2024-05-09 16:25:05 -070024#include <com/android/media/permission/INativePermissionController.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070025#include <cutils/misc.h>
26#include <cutils/config_utils.h>
Mathias Agopiane762be92013-05-09 16:26:45 -070027#include <cutils/compiler.h>
Glenn Kastend1d8f232011-07-08 09:34:50 -070028#include <utils/String8.h>
Mathias Agopian65ab4712010-07-14 17:59:35 -070029#include <utils/Vector.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070030#include <utils/SortedVector.h>
Steven Moreland2f348142019-07-02 15:59:07 -070031#include <binder/ActivityManager.h>
Glenn Kastend2dcb082011-02-03 16:55:26 -080032#include <binder/BinderService.h>
Svet Ganovf4ddfef2018-01-16 07:37:58 -080033#include <binder/IUidObserver.h>
Dima Zavin64760242011-05-11 14:15:23 -070034#include <system/audio.h>
Dima Zavin7394a4f2011-06-13 18:16:26 -070035#include <system/audio_policy.h>
Eric Laurent7c7f10b2011-06-17 21:29:58 -070036#include <media/ToneGenerator.h>
37#include <media/AudioEffect.h>
Eric Laurentbaac1832014-12-01 17:52:59 -080038#include <media/AudioPolicy.h>
Atneya Nair9f91a5e2024-05-09 16:25:05 -070039#include <media/NativePermissionController.h>
Eric Laurent0d13fea2022-11-04 17:12:08 +010040#include <media/UsecaseValidator.h>
Kevin Rocard8be94972019-02-22 13:26:25 -080041#include <mediautils/ServiceUtilities.h>
bryant_liuba2b4392014-06-11 16:49:30 +080042#include "AudioPolicyEffects.h"
Ytai Ben-Tsvi1ef846b2020-03-26 09:41:15 -070043#include "CaptureStateNotifier.h"
Eric Laurent81dd0f52021-07-05 11:54:40 +020044#include "Spatializer.h"
François Gaffie962ba212019-04-03 16:21:39 +020045#include <AudioPolicyInterface.h>
Michael Groovercfd28302018-12-11 19:16:46 -080046#include <android/hardware/BnSensorPrivacyListener.h>
Svet Ganov3e5f14f2021-05-13 22:51:08 +000047#include <android/content/AttributionSourceState.h>
Philip P. Moltmannbda45752020-07-17 16:41:18 -070048
Svet Ganovf4ddfef2018-01-16 07:37:58 -080049#include <unordered_map>
bryant_liuba2b4392014-06-11 16:49:30 +080050
Mathias Agopian65ab4712010-07-14 17:59:35 -070051namespace android {
52
Svet Ganov3e5f14f2021-05-13 22:51:08 +000053using content::AttributionSourceState;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070054using media::audio::common::AudioConfig;
55using media::audio::common::AudioConfigBase;
Mikhail Naganovf4a75362021-09-16 00:02:54 +000056using media::audio::common::AudioDevice;
57using media::audio::common::AudioDeviceDescription;
Mikhail Naganov57bd06f2021-08-10 16:41:54 -070058using media::audio::common::AudioFormatDescription;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070059using media::audio::common::AudioMode;
60using media::audio::common::AudioSource;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070061using media::audio::common::AudioStreamType;
62using media::audio::common::AudioUsage;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070063using media::audio::common::AudioUuid;
Mikhail Naganov0078ee52021-09-30 23:06:20 +000064using media::audio::common::Int;
Svet Ganov3e5f14f2021-05-13 22:51:08 +000065
Mathias Agopian65ab4712010-07-14 17:59:35 -070066// ----------------------------------------------------------------------------
67
Atneya Nair5b1ed642023-06-23 14:43:37 -070068namespace media::audiopolicy {
69 class AudioRecordClient;
70}
71
72using ::android::media::audiopolicy::AudioRecordClient;
Atneya Nair9f91a5e2024-05-09 16:25:05 -070073using ::com::android::media::permission::INativePermissionController;
74using ::com::android::media::permission::NativePermissionController;
Atneya Nair5b1ed642023-06-23 14:43:37 -070075
Glenn Kastend2dcb082011-02-03 16:55:26 -080076class AudioPolicyService :
77 public BinderService<AudioPolicyService>,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080078 public media::BnAudioPolicyService,
Eric Laurent81dd0f52021-07-05 11:54:40 +020079 public IBinder::DeathRecipient,
80 public SpatializerPolicyCallback
Mathias Agopian65ab4712010-07-14 17:59:35 -070081{
Andy Hung1d312b92023-01-03 16:12:50 -080082 friend class sp<AudioPolicyService>;
Mathias Agopian65ab4712010-07-14 17:59:35 -070083
84public:
Glenn Kastend2dcb082011-02-03 16:55:26 -080085 // for BinderService
Mathias Agopiane762be92013-05-09 16:26:45 -070086 static const char *getServiceName() ANDROID_API { return "media.audio_policy"; }
Mathias Agopian65ab4712010-07-14 17:59:35 -070087
88 virtual status_t dump(int fd, const Vector<String16>& args);
89
90 //
91 // BnAudioPolicyService (see AudioPolicyInterface for method descriptions)
92 //
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080093 binder::Status onNewAudioModulesAvailable() override;
94 binder::Status setDeviceConnectionState(
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080095 media::AudioPolicyDeviceState state,
Nathalie Le Clair88fa2752021-11-23 13:03:41 +010096 const android::media::audio::common::AudioPort& port,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -070097 const AudioFormatDescription& encodedFormat) override;
Mikhail Naganovf4a75362021-09-16 00:02:54 +000098 binder::Status getDeviceConnectionState(const AudioDevice& device,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -080099 media::AudioPolicyDeviceState* _aidl_return) override;
100 binder::Status handleDeviceConfigChange(
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000101 const AudioDevice& device,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800102 const std::string& deviceName,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700103 const AudioFormatDescription& encodedFormat) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700104 binder::Status setPhoneState(AudioMode state, int32_t uid) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800105 binder::Status setForceUse(media::AudioPolicyForceUse usage,
106 media::AudioPolicyForcedConfig config) override;
107 binder::Status getForceUse(media::AudioPolicyForceUse usage,
108 media::AudioPolicyForcedConfig* _aidl_return) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700109 binder::Status getOutput(AudioStreamType stream, int32_t* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700110 binder::Status getOutputForAttr(const media::audio::common::AudioAttributes& attr,
111 int32_t session,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000112 const AttributionSourceState &attributionSource,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700113 const AudioConfig& config,
Eric Laurentf99edd32021-02-01 15:57:33 +0100114 int32_t flags, int32_t selectedDeviceId,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800115 media::GetOutputForAttrResponse* _aidl_return) override;
116 binder::Status startOutput(int32_t portId) override;
117 binder::Status stopOutput(int32_t portId) override;
118 binder::Status releaseOutput(int32_t portId) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700119 binder::Status getInputForAttr(const media::audio::common::AudioAttributes& attr, int32_t input,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700120 int32_t riid, int32_t session,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000121 const AttributionSourceState &attributionSource,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700122 const AudioConfigBase& config, int32_t flags,
Eric Laurentf99edd32021-02-01 15:57:33 +0100123 int32_t selectedDeviceId,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800124 media::GetInputForAttrResponse* _aidl_return) override;
125 binder::Status startInput(int32_t portId) override;
126 binder::Status stopInput(int32_t portId) override;
127 binder::Status releaseInput(int32_t portId) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700128 binder::Status initStreamVolume(AudioStreamType stream, int32_t indexMin,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800129 int32_t indexMax) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700130 binder::Status setStreamVolumeIndex(AudioStreamType stream,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000131 const AudioDeviceDescription& device,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800132 int32_t index) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700133 binder::Status getStreamVolumeIndex(AudioStreamType stream,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000134 const AudioDeviceDescription& device,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800135 int32_t* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700136 binder::Status setVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000137 const AudioDeviceDescription& device,
Mikhail Naganov21a32ec2021-07-08 14:40:12 -0700138 int32_t index) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700139 binder::Status getVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000140 const AudioDeviceDescription& device,
Mikhail Naganov21a32ec2021-07-08 14:40:12 -0700141 int32_t* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700142 binder::Status getMaxVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800143 int32_t* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700144 binder::Status getMinVolumeIndexForAttributes(const media::audio::common::AudioAttributes& attr,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800145 int32_t* _aidl_return) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700146 binder::Status getStrategyForStream(AudioStreamType stream,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800147 int32_t* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700148 binder::Status getDevicesForAttributes(const media::audio::common::AudioAttributes& attr,
Andy Hung6d23c0f2022-02-16 09:37:15 -0800149 bool forVolume,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000150 std::vector<AudioDevice>* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800151 binder::Status getOutputForEffect(const media::EffectDescriptor& desc,
152 int32_t* _aidl_return) override;
153 binder::Status registerEffect(const media::EffectDescriptor& desc, int32_t io, int32_t strategy,
154 int32_t session, int32_t id) override;
155 binder::Status unregisterEffect(int32_t id) override;
156 binder::Status setEffectEnabled(int32_t id, bool enabled) override;
157 binder::Status moveEffectsToIo(const std::vector<int32_t>& ids, int32_t io) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700158 binder::Status isStreamActive(AudioStreamType stream, int32_t inPastMs,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800159 bool* _aidl_return) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700160 binder::Status isStreamActiveRemotely(AudioStreamType stream, int32_t inPastMs,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800161 bool* _aidl_return) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700162 binder::Status isSourceActive(AudioSource source, bool* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800163 binder::Status queryDefaultPreProcessing(
Mikhail Naganov0078ee52021-09-30 23:06:20 +0000164 int32_t audioSession, Int* count,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800165 std::vector<media::EffectDescriptor>* _aidl_return) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700166 binder::Status addSourceDefaultEffect(const AudioUuid& type,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800167 const std::string& opPackageName,
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700168 const AudioUuid& uuid, int32_t priority,
169 AudioSource source,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800170 int32_t* _aidl_return) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700171 binder::Status addStreamDefaultEffect(const AudioUuid& type,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800172 const std::string& opPackageName,
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700173 const AudioUuid& uuid, int32_t priority,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700174 AudioUsage usage, int32_t* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800175 binder::Status removeSourceDefaultEffect(int32_t id) override;
176 binder::Status removeStreamDefaultEffect(int32_t id) override;
177 binder::Status setSupportedSystemUsages(
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700178 const std::vector<AudioUsage>& systemUsages) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800179 binder::Status setAllowedCapturePolicy(int32_t uid, int32_t capturePolicy) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700180 binder::Status getOffloadSupport(const media::audio::common::AudioOffloadInfo& info,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800181 media::AudioOffloadMode* _aidl_return) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700182 binder::Status isDirectOutputSupported(const AudioConfigBase& config,
Mikhail Naganov1c400902023-05-17 11:48:43 -0700183 const media::audio::common::AudioAttributes& attributes,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800184 bool* _aidl_return) override;
185 binder::Status listAudioPorts(media::AudioPortRole role, media::AudioPortType type,
Atneya Nair638a6e42022-12-18 16:45:15 -0800186 Int* count, std::vector<media::AudioPortFw>* ports,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800187 int32_t* _aidl_return) override;
Mikhail Naganov5edc5ed2023-03-23 14:52:15 -0700188 binder::Status listDeclaredDevicePorts(media::AudioPortRole role,
189 std::vector<media::AudioPortFw>* _aidl_return) override;
Mikhail Naganov17031562022-02-23 23:00:27 +0000190 binder::Status getAudioPort(int portId,
Atneya Nair638a6e42022-12-18 16:45:15 -0800191 media::AudioPortFw* _aidl_return) override;
Atneya Nair3afdbd12022-12-18 16:14:18 -0800192 binder::Status createAudioPatch(const media::AudioPatchFw& patch, int32_t handle,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800193 int32_t* _aidl_return) override;
194 binder::Status releaseAudioPatch(int32_t handle) override;
Atneya Nair3afdbd12022-12-18 16:14:18 -0800195 binder::Status listAudioPatches(Int* count, std::vector<media::AudioPatchFw>* patches,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800196 int32_t* _aidl_return) override;
Atneya Nair7a9594f2022-12-18 17:26:26 -0800197 binder::Status setAudioPortConfig(const media::AudioPortConfigFw& config) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800198 binder::Status registerClient(const sp<media::IAudioPolicyServiceClient>& client) override;
199 binder::Status setAudioPortCallbacksEnabled(bool enabled) override;
200 binder::Status setAudioVolumeGroupCallbacksEnabled(bool enabled) override;
201 binder::Status acquireSoundTriggerSession(media::SoundTriggerSession* _aidl_return) override;
202 binder::Status releaseSoundTriggerSession(int32_t session) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700203 binder::Status getPhoneState(AudioMode* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800204 binder::Status registerPolicyMixes(const std::vector<media::AudioMix>& mixes,
205 bool registration) override;
Jan Sebechlebsky0af8e872023-08-11 14:45:08 +0200206 binder::Status updatePolicyMixes(
207 const ::std::vector<::android::media::AudioMixUpdate>& updates) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800208 binder::Status setUidDeviceAffinities(int32_t uid,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000209 const std::vector<AudioDevice>& devices) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800210 binder::Status removeUidDeviceAffinities(int32_t uid) override;
211 binder::Status setUserIdDeviceAffinities(
212 int32_t userId,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000213 const std::vector<AudioDevice>& devices) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800214 binder::Status removeUserIdDeviceAffinities(int32_t userId) override;
Atneya Nair7a9594f2022-12-18 17:26:26 -0800215 binder::Status startAudioSource(const media::AudioPortConfigFw& source,
Mikhail Naganov1c400902023-05-17 11:48:43 -0700216 const media::audio::common::AudioAttributes& attributes,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800217 int32_t* _aidl_return) override;
218 binder::Status stopAudioSource(int32_t portId) override;
219 binder::Status setMasterMono(bool mono) override;
220 binder::Status getMasterMono(bool* _aidl_return) override;
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700221 binder::Status getStreamVolumeDB(AudioStreamType stream, int32_t index,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000222 const AudioDeviceDescription& device,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800223 float* _aidl_return) override;
Mikhail Naganov0078ee52021-09-30 23:06:20 +0000224 binder::Status getSurroundFormats(Int* count,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700225 std::vector<AudioFormatDescription>* formats,
Kriti Dang877b27e2021-02-02 12:10:40 +0100226 std::vector<bool>* formatsEnabled) override;
Kriti Dang6537def2021-03-02 13:46:59 +0100227 binder::Status getReportedSurroundFormats(
Mikhail Naganov0078ee52021-09-30 23:06:20 +0000228 Int* count, std::vector<AudioFormatDescription>* formats) override;
Pattydd807582021-11-04 21:01:03 +0800229 binder::Status getHwOffloadFormatsSupportedForBluetoothMedia(
230 const AudioDeviceDescription& device,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700231 std::vector<AudioFormatDescription>* _aidl_return) override;
232 binder::Status setSurroundFormatEnabled(const AudioFormatDescription& audioFormat,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800233 bool enabled) override;
Oscar Azucena829d90d2022-01-28 17:17:56 -0800234 binder::Status setAssistantServicesUids(const std::vector<int32_t>& uids) override;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800235 binder::Status setActiveAssistantServicesUids(const std::vector<int32_t>& activeUids) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800236 binder::Status setA11yServicesUids(const std::vector<int32_t>& uids) override;
237 binder::Status setCurrentImeUid(int32_t uid) override;
238 binder::Status isHapticPlaybackSupported(bool* _aidl_return) override;
Carter Hsu325a8eb2022-01-19 19:56:51 +0800239 binder::Status isUltrasoundSupported(bool* _aidl_return) override;
Atneya Nair698f5ef2022-12-15 16:15:09 -0800240 binder::Status isHotwordStreamSupported(bool lookbackAudio, bool* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800241 binder::Status listAudioProductStrategies(
242 std::vector<media::AudioProductStrategy>* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700243 binder::Status getProductStrategyFromAudioAttributes(
244 const media::audio::common::AudioAttributes& aa,
245 bool fallbackOnDefault,
246 int32_t* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800247 binder::Status listAudioVolumeGroups(
248 std::vector<media::AudioVolumeGroup>* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700249 binder::Status getVolumeGroupFromAudioAttributes(
250 const media::audio::common::AudioAttributes& aa,
251 bool fallbackOnDefault,
252 int32_t* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800253 binder::Status setRttEnabled(bool enabled) override;
254 binder::Status isCallScreenModeSupported(bool* _aidl_return) override;
255 binder::Status setDevicesRoleForStrategy(
256 int32_t strategy, media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000257 const std::vector<AudioDevice>& devices) override;
Paul Wang5d7cdb52022-11-22 09:45:06 +0000258 binder::Status removeDevicesRoleForStrategy(
259 int32_t strategy, media::DeviceRole role,
260 const std::vector<AudioDevice>& devices) override;
261 binder::Status clearDevicesRoleForStrategy(
262 int32_t strategy,
263 media::DeviceRole role) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800264 binder::Status getDevicesForRoleAndStrategy(
265 int32_t strategy, media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000266 std::vector<AudioDevice>* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800267 binder::Status setDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700268 AudioSource audioSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800269 media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000270 const std::vector<AudioDevice>& devices) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800271 binder::Status addDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700272 AudioSource audioSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800273 media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000274 const std::vector<AudioDevice>& devices) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800275 binder::Status removeDevicesRoleForCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700276 AudioSource audioSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800277 media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000278 const std::vector<AudioDevice>& devices) override;
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700279 binder::Status clearDevicesRoleForCapturePreset(AudioSource audioSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800280 media::DeviceRole role) override;
281 binder::Status getDevicesForRoleAndCapturePreset(
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700282 AudioSource audioSource,
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800283 media::DeviceRole role,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000284 std::vector<AudioDevice>* _aidl_return) override;
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800285 binder::Status registerSoundTriggerCaptureStateListener(
286 const sp<media::ICaptureStateListener>& listener, bool* _aidl_return) override;
Ari Hausman-Cohen433722e2018-04-24 14:25:22 -0700287
Eric Laurent81dd0f52021-07-05 11:54:40 +0200288 binder::Status getSpatializer(const sp<media::INativeSpatializerCallback>& callback,
289 media::GetSpatializerResponse* _aidl_return) override;
290 binder::Status canBeSpatialized(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700291 const std::optional<media::audio::common::AudioAttributes>& attr,
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700292 const std::optional<AudioConfig>& config,
Mikhail Naganovf4a75362021-09-16 00:02:54 +0000293 const std::vector<AudioDevice>& devices,
Eric Laurent81dd0f52021-07-05 11:54:40 +0200294 bool* _aidl_return) override;
295
Mikhail Naganov1c400902023-05-17 11:48:43 -0700296 binder::Status getDirectPlaybackSupport(const media::audio::common::AudioAttributes& attr,
jiabin2b9d5a12021-12-10 01:06:29 +0000297 const AudioConfig& config,
298 media::AudioDirectMode* _aidl_return) override;
299
Mikhail Naganov1c400902023-05-17 11:48:43 -0700300 binder::Status getDirectProfilesForAttributes(const media::audio::common::AudioAttributes& attr,
Dorin Drimusf2196d82022-01-03 12:11:18 +0100301 std::vector<media::audio::common::AudioProfile>* _aidl_return) override;
302
jiabina84c3d32022-12-02 18:59:55 +0000303 binder::Status getSupportedMixerAttributes(
304 int32_t portId,
305 std::vector<media::AudioMixerAttributesInternal>* _aidl_return) override;
306 binder::Status setPreferredMixerAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700307 const media::audio::common::AudioAttributes& attr,
jiabina84c3d32022-12-02 18:59:55 +0000308 int32_t portId,
309 int32_t uid,
310 const media::AudioMixerAttributesInternal& mixerAttr) override;
311 binder::Status getPreferredMixerAttributes(
Mikhail Naganov1c400902023-05-17 11:48:43 -0700312 const media::audio::common::AudioAttributes& attr,
jiabina84c3d32022-12-02 18:59:55 +0000313 int32_t portId,
314 std::optional<media::AudioMixerAttributesInternal>* _aidl_return) override;
Mikhail Naganov1c400902023-05-17 11:48:43 -0700315 binder::Status clearPreferredMixerAttributes(const media::audio::common::AudioAttributes& attr,
jiabina84c3d32022-12-02 18:59:55 +0000316 int32_t portId,
317 int32_t uid) override;
Marvin Raminbdefaf02023-11-01 09:10:32 +0100318 binder::Status getRegisteredPolicyMixes(
319 std::vector <::android::media::AudioMix>* mixes) override;
jiabina84c3d32022-12-02 18:59:55 +0000320
Atneya Nair9f91a5e2024-05-09 16:25:05 -0700321 // Should only be called by AudioService to push permission data down to audioserver
322 binder::Status getPermissionController(sp<INativePermissionController>* out) override;
323
Eric Laurent81dd0f52021-07-05 11:54:40 +0200324 status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) override;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700325
326 // IBinder::DeathRecipient
327 virtual void binderDied(const wp<IBinder>& who);
328
Eric Laurentf5ada6e2014-10-09 17:49:00 -0700329 // RefBase
330 virtual void onFirstRef();
331
Andy Hungb08b3752024-01-09 19:05:23 -0800332 // Commence initialization when AudioSystem is ready.
333 void onAudioSystemReady();
334
Mathias Agopian65ab4712010-07-14 17:59:35 -0700335 //
Dima Zavinfce7a472011-04-19 22:30:36 -0700336 // Helpers for the struct audio_policy_service_ops implementation.
337 // This is used by the audio policy manager for certain operations that
338 // are implemented by the policy service.
Mathias Agopian65ab4712010-07-14 17:59:35 -0700339 //
Dima Zavinfce7a472011-04-19 22:30:36 -0700340 virtual void setParameters(audio_io_handle_t ioHandle,
341 const char *keyValuePairs,
342 int delayMs);
343
344 virtual status_t setStreamVolume(audio_stream_type_t stream,
Eric Laurentde070132010-07-13 04:45:46 -0700345 float volume,
346 audio_io_handle_t output,
347 int delayMs = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700348 virtual status_t setVoiceVolume(float volume, int delayMs = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700349
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800350 void doOnNewAudioModulesAvailable();
351 status_t doStopOutput(audio_port_handle_t portId);
352 void doReleaseOutput(audio_port_handle_t portId);
Eric Laurent203b1a12014-04-01 10:34:16 -0700353
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800354 status_t clientCreateAudioPatch(const struct audio_patch *patch,
355 audio_patch_handle_t *handle,
356 int delayMs);
357 status_t clientReleaseAudioPatch(audio_patch_handle_t handle,
358 int delayMs);
359 virtual status_t clientSetAudioPortConfig(const struct audio_port_config *config,
360 int delayMs);
Eric Laurentb52c1522014-05-20 11:27:36 -0700361
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800362 void removeNotificationClient(uid_t uid, pid_t pid);
363 void onAudioPortListUpdate();
364 void doOnAudioPortListUpdate();
365 void onAudioPatchListUpdate();
366 void doOnAudioPatchListUpdate();
Eric Laurente8726fe2015-06-26 09:39:24 -0700367
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800368 void onDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
369 void doOnDynamicPolicyMixStateUpdate(const String8& regId, int32_t state);
370 void onRecordingConfigurationUpdate(int event,
371 const record_client_info_t *clientInfo,
372 const audio_config_base_t *clientConfig,
373 std::vector<effect_descriptor_t> clientEffects,
374 const audio_config_base_t *deviceConfig,
375 std::vector<effect_descriptor_t> effects,
376 audio_patch_handle_t patchHandle,
377 audio_source_t source);
378 void doOnRecordingConfigurationUpdate(int event,
379 const record_client_info_t *clientInfo,
380 const audio_config_base_t *clientConfig,
381 std::vector<effect_descriptor_t> clientEffects,
382 const audio_config_base_t *deviceConfig,
383 std::vector<effect_descriptor_t> effects,
384 audio_patch_handle_t patchHandle,
385 audio_source_t source);
François Gaffiecfe17322018-11-07 13:41:29 +0100386
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800387 void onAudioVolumeGroupChanged(volume_group_t group, int flags);
388 void doOnAudioVolumeGroupChanged(volume_group_t group, int flags);
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700389
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800390 void onRoutingUpdated();
391 void doOnRoutingUpdated();
Eric Laurentdf3dc7e2014-07-27 18:39:40 -0700392
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000393 void onVolumeRangeInitRequest();
394 void doOnVolumeRangeInitRequest();
395
Eric Laurent81dd0f52021-07-05 11:54:40 +0200396 /**
397 * Spatializer SpatializerPolicyCallback implementation.
398 * onCheckSpatializer() sends an event on mOutputCommandThread which executes
399 * doOnCheckSpatializer() to check if a Spatializer output must be opened or closed
400 * by audio policy manager and attach/detach the spatializer effect accordingly.
401 */
402 void onCheckSpatializer() override;
Andy Hung79eacdb2023-11-30 19:34:24 -0800403 void onCheckSpatializer_l() REQUIRES(mMutex);
Eric Laurent81dd0f52021-07-05 11:54:40 +0200404 void doOnCheckSpatializer();
405
Andy Hung79eacdb2023-11-30 19:34:24 -0800406 void onUpdateActiveSpatializerTracks_l() REQUIRES(mMutex);
Eric Laurent15903592022-02-24 20:44:36 +0100407 void doOnUpdateActiveSpatializerTracks();
408
409
Ytai Ben-Tsvi0a4904a2021-01-06 12:57:05 -0800410 void setEffectSuspended(int effectId,
411 audio_session_t sessionId,
412 bool suspended);
François Gaffiecfe17322018-11-07 13:41:29 +0100413
Mathias Agopian65ab4712010-07-14 17:59:35 -0700414private:
Mathias Agopiane762be92013-05-09 16:26:45 -0700415 AudioPolicyService() ANDROID_API;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700416 virtual ~AudioPolicyService();
417
Andy Hung79eacdb2023-11-30 19:34:24 -0800418 status_t dumpInternals(int fd) REQUIRES(mMutex);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700419
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800420 // Handles binder shell commands
421 virtual status_t shellCommand(int in, int out, int err, Vector<String16>& args);
422
Eric Laurent8c7ef892021-06-10 13:32:16 +0200423
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800424 // Sets whether the given UID records only silence
Andy Hung79eacdb2023-11-30 19:34:24 -0800425 virtual void setAppState_l(sp<AudioRecordClient> client, app_state_t state) REQUIRES(mMutex);
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800426
427 // Overrides the UID state as if it is idle
428 status_t handleSetUidState(Vector<String16>& args, int err);
429
430 // Clears the override for the UID state
431 status_t handleResetUidState(Vector<String16>& args, int err);
432
433 // Gets the UID state
434 status_t handleGetUidState(Vector<String16>& args, int out, int err);
435
436 // Prints the shell command help
437 status_t printHelp(int out);
438
Eric Laurent99fcae42018-05-17 16:59:18 -0700439 std::string getDeviceTypeStrForPortId(audio_port_handle_t portId);
440
Ari Hausman-Cohen24628312018-08-13 15:01:09 -0700441 status_t getAudioPolicyEffects(sp<AudioPolicyEffects>& audioPolicyEffects);
442
Eric Laurente8c8b432018-10-17 10:08:02 -0700443 app_state_t apmStatFromAmState(int amState);
444
Hayden Gomes524159d2019-12-23 14:41:47 -0800445 bool isSupportedSystemUsage(audio_usage_t usage);
Eric Laurentb0eff0f2021-11-09 16:05:49 +0100446 status_t validateUsage(const audio_attributes_t& attr);
447 status_t validateUsage(const audio_attributes_t& attr,
448 const AttributionSourceState& attributionSource);
Hayden Gomes524159d2019-12-23 14:41:47 -0800449
Eric Laurente8c8b432018-10-17 10:08:02 -0700450 void updateUidStates();
Andy Hung79eacdb2023-11-30 19:34:24 -0800451 void updateUidStates_l() REQUIRES(mMutex);
Eric Laurente8c8b432018-10-17 10:08:02 -0700452
Andy Hung79eacdb2023-11-30 19:34:24 -0800453 void silenceAllRecordings_l() REQUIRES(mMutex);
Michael Groovercfd28302018-12-11 19:16:46 -0800454
Eric Laurent2dc962b2019-03-01 08:25:25 -0800455 static bool isVirtualSource(audio_source_t source);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800456
Eric Laurented726cc2021-07-01 14:26:41 +0200457 /** returns true if the audio source must be silenced when the corresponding app op is denied.
458 * false if the audio source does not actually capture from the microphone while still
459 * being mapped to app op OP_RECORD_AUDIO and not a specialized op tracked separately.
460 * See getOpForSource().
461 */
462 static bool isAppOpSource(audio_source_t source);
463
Eric Laurent0d13fea2022-11-04 17:12:08 +0100464 status_t registerOutput(audio_io_handle_t output,
465 const audio_config_base_t& config,
466 const audio_output_flags_t flags);
467 status_t unregisterOutput(audio_io_handle_t output);
468
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800469 // If recording we need to make sure the UID is allowed to do that. If the UID is idle
470 // then it cannot record and gets buffers with zeros - silence. As soon as the UID
471 // transitions to an active state we will start reporting buffers with data. This approach
472 // transparently handles recording while the UID transitions between idle/active state
473 // avoiding to get stuck in a state receiving non-empty buffers while idle or in a state
474 // receiving empty buffers while active.
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700475 class UidPolicy : public BnUidObserver, public virtual IBinder::DeathRecipient {
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800476 public:
477 explicit UidPolicy(wp<AudioPolicyService> service)
Eric Laurent6ede98f2019-06-11 14:50:30 -0700478 : mService(service), mObserverRegistered(false),
Oscar Azucena829d90d2022-01-28 17:17:56 -0800479 mCurrentImeUid(0),
Ahaan Ugalef51ce002021-08-04 16:34:20 -0700480 mRttEnabled(false) {}
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800481
482 void registerSelf();
483 void unregisterSelf();
484
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700485 // IBinder::DeathRecipient implementation
486 void binderDied(const wp<IBinder> &who) override;
487
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800488 bool isUidActive(uid_t uid);
Eric Laurente8c8b432018-10-17 10:08:02 -0700489 int getUidState(uid_t uid);
Oscar Azucena829d90d2022-01-28 17:17:56 -0800490 void setAssistantUids(const std::vector<uid_t>& uids);
491 bool isAssistantUid(uid_t uid);
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800492 void setActiveAssistantUids(const std::vector<uid_t>& activeUids);
493 bool isActiveAssistantUid(uid_t uid);
Eric Laurentb78763e2018-10-17 10:08:02 -0700494 void setA11yUids(const std::vector<uid_t>& uids) { mA11yUids.clear(); mA11yUids = uids; }
495 bool isA11yUid(uid_t uid);
Eric Laurent4eb58f12018-12-07 16:41:02 -0800496 bool isA11yOnTop();
Kohsuke Yatoha623a132020-03-24 20:10:26 -0700497 void setCurrentImeUid(uid_t uid) { mCurrentImeUid = uid; }
498 bool isCurrentImeUid(uid_t uid) { return uid == mCurrentImeUid; }
Eric Laurent6ede98f2019-06-11 14:50:30 -0700499 void setRttEnabled(bool enabled) { mRttEnabled = enabled; }
500 bool isRttEnabled() { return mRttEnabled; }
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800501
Mikhail Naganoveae73eb2018-04-03 16:57:36 -0700502 // BnUidObserver implementation
503 void onUidActive(uid_t uid) override;
504 void onUidGone(uid_t uid, bool disabled) override;
505 void onUidIdle(uid_t uid, bool disabled) override;
Hui Yu13ad0eb2019-09-09 10:27:07 -0700506 void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq,
Austin Borger65577682022-02-17 00:25:43 +0000507 int32_t capability) override;
Austin Borgerdddb7552023-03-30 17:53:01 -0700508 void onUidProcAdjChanged(uid_t uid, int32_t adj) override;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800509
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800510
Eric Laurente8c8b432018-10-17 10:08:02 -0700511 void updateUid(std::unordered_map<uid_t, std::pair<bool, int>> *uids,
512 uid_t uid, bool active, int state, bool insert);
513
Oscar Azucena829d90d2022-01-28 17:17:56 -0800514 void dumpInternals(int fd);
515
Eric Laurente8c8b432018-10-17 10:08:02 -0700516 private:
517 void notifyService();
Eric Laurente8c8b432018-10-17 10:08:02 -0700518 void updateUidLocked(std::unordered_map<uid_t, std::pair<bool, int>> *uids,
519 uid_t uid, bool active, int state, bool insert);
520 void checkRegistered();
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800521
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800522 wp<AudioPolicyService> mService;
Andy Hung79eacdb2023-11-30 19:34:24 -0800523 audio_utils::mutex mMutex{audio_utils::MutexOrder::kUidPolicy_Mutex};
Steven Moreland2f348142019-07-02 15:59:07 -0700524 ActivityManager mAm;
Mikhail Naganov197d50a2020-04-30 22:37:43 +0000525 bool mObserverRegistered = false;
Andy Hung79eacdb2023-11-30 19:34:24 -0800526 std::unordered_map<uid_t, std::pair<bool, int>> mCachedUids GUARDED_BY(mMutex);
Oscar Azucena829d90d2022-01-28 17:17:56 -0800527 std::vector<uid_t> mAssistantUids;
Oscar Azucenac2cdda32022-01-31 19:10:39 -0800528 std::vector<uid_t> mActiveAssistantUids;
Eric Laurentb78763e2018-10-17 10:08:02 -0700529 std::vector<uid_t> mA11yUids;
Mikhail Naganov197d50a2020-04-30 22:37:43 +0000530 uid_t mCurrentImeUid = -1;
531 bool mRttEnabled = false;
Svet Ganovf4ddfef2018-01-16 07:37:58 -0800532 };
533
Michael Groovercfd28302018-12-11 19:16:46 -0800534 // If sensor privacy is enabled then all apps, including those that are active, should be
535 // prevented from recording. This is handled similar to idle UIDs, any app that attempts
536 // to record while sensor privacy is enabled will receive buffers with zeros. As soon as
537 // sensor privacy is disabled active apps will receive the expected data when recording.
538 class SensorPrivacyPolicy : public hardware::BnSensorPrivacyListener {
539 public:
540 explicit SensorPrivacyPolicy(wp<AudioPolicyService> service)
541 : mService(service) {}
542
543 void registerSelf();
544 void unregisterSelf();
545
546 bool isSensorPrivacyEnabled();
547
Evan Seversond8dc6832022-01-27 10:47:03 -0800548 binder::Status onSensorPrivacyChanged(int toggleType, int sensor,
549 bool enabled);
Michael Groovercfd28302018-12-11 19:16:46 -0800550
Jyoti Bhayanac05a1192024-02-11 13:19:29 +0000551 binder::Status onSensorPrivacyStateChanged(int, int, int) {
552 return binder::Status::ok();
553 }
554
Michael Groovercfd28302018-12-11 19:16:46 -0800555 private:
556 wp<AudioPolicyService> mService;
Mikhail Naganov197d50a2020-04-30 22:37:43 +0000557 std::atomic_bool mSensorPrivacyEnabled = false;
Michael Groovercfd28302018-12-11 19:16:46 -0800558 };
559
Eric Laurentdcd4ab12018-06-29 17:45:13 -0700560 // Thread used to send audio config commands to audio flinger
Glenn Kasten85ab62c2012-11-01 11:11:38 -0700561 // For audio config commands, it is necessary because audio flinger requires that the calling
562 // process (user) has permission to modify audio settings.
Atneya Nair5b1ed642023-06-23 14:43:37 -0700563 public:
Mathias Agopian65ab4712010-07-14 17:59:35 -0700564 class AudioCommandThread : public Thread {
565 class AudioCommand;
566 public:
567
568 // commands for tone AudioCommand
569 enum {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700570 SET_VOLUME,
571 SET_PARAMETERS,
Eric Laurentbfb1b832013-01-07 09:53:42 -0800572 SET_VOICE_VOLUME,
573 STOP_OUTPUT,
Eric Laurent951f4552014-05-20 10:48:17 -0700574 RELEASE_OUTPUT,
575 CREATE_AUDIO_PATCH,
576 RELEASE_AUDIO_PATCH,
Eric Laurentb52c1522014-05-20 11:27:36 -0700577 UPDATE_AUDIOPORT_LIST,
Eric Laurente1715a42014-05-20 11:30:42 -0700578 UPDATE_AUDIOPATCH_LIST,
François Gaffiecfe17322018-11-07 13:41:29 +0100579 CHANGED_AUDIOVOLUMEGROUP,
Eric Laurente1715a42014-05-20 11:30:42 -0700580 SET_AUDIOPORT_CONFIG,
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800581 DYN_POLICY_MIX_STATE_UPDATE,
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700582 RECORDING_CONFIGURATION_UPDATE,
583 SET_EFFECT_SUSPENDED,
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000584 AUDIO_MODULES_UPDATE,
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700585 ROUTING_UPDATED,
Eric Laurent81dd0f52021-07-05 11:54:40 +0200586 UPDATE_UID_STATES,
Eric Laurent15903592022-02-24 20:44:36 +0100587 CHECK_SPATIALIZER_OUTPUT, // verify if spatializer effect should be created or moved
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000588 UPDATE_ACTIVE_SPATIALIZER_TRACKS, // Update active track counts on spalializer output
589 VOL_RANGE_INIT_REQUEST, // request to reset the volume range indices
Mathias Agopian65ab4712010-07-14 17:59:35 -0700590 };
591
Eric Laurentbfb1b832013-01-07 09:53:42 -0800592 AudioCommandThread (String8 name, const wp<AudioPolicyService>& service);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700593 virtual ~AudioCommandThread();
594
595 status_t dump(int fd);
596
597 // Thread virtuals
598 virtual void onFirstRef();
599 virtual bool threadLoop();
600
601 void exit();
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800602 status_t volumeCommand(audio_stream_type_t stream, float volume,
603 audio_io_handle_t output, int delayMs = 0);
604 status_t parametersCommand(audio_io_handle_t ioHandle,
605 const char *keyValuePairs, int delayMs = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700606 status_t voiceVolumeCommand(float volume, int delayMs = 0);
Eric Laurentd7fe0862018-07-14 16:48:01 -0700607 void stopOutputCommand(audio_port_handle_t portId);
608 void releaseOutputCommand(audio_port_handle_t portId);
Eric Laurent0ede8922014-05-09 18:04:42 -0700609 status_t sendCommand(sp<AudioCommand>& command, int delayMs = 0);
610 void insertCommand_l(sp<AudioCommand>& command, int delayMs = 0);
Eric Laurent951f4552014-05-20 10:48:17 -0700611 status_t createAudioPatchCommand(const struct audio_patch *patch,
612 audio_patch_handle_t *handle,
613 int delayMs);
614 status_t releaseAudioPatchCommand(audio_patch_handle_t handle,
615 int delayMs);
Eric Laurentb52c1522014-05-20 11:27:36 -0700616 void updateAudioPortListCommand();
617 void updateAudioPatchListCommand();
François Gaffiecfe17322018-11-07 13:41:29 +0100618 void changeAudioVolumeGroupCommand(volume_group_t group, int flags);
Eric Laurente1715a42014-05-20 11:30:42 -0700619 status_t setAudioPortConfigCommand(const struct audio_port_config *config,
620 int delayMs);
Eric Laurenta9f86652018-11-28 17:23:11 -0800621 void dynamicPolicyMixStateUpdateCommand(const String8& regId,
622 int32_t state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800623 void recordingConfigurationUpdateCommand(
Eric Laurenta9f86652018-11-28 17:23:11 -0800624 int event,
625 const record_client_info_t *clientInfo,
626 const audio_config_base_t *clientConfig,
627 std::vector<effect_descriptor_t> clientEffects,
628 const audio_config_base_t *deviceConfig,
629 std::vector<effect_descriptor_t> effects,
630 audio_patch_handle_t patchHandle,
631 audio_source_t source);
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700632 void setEffectSuspendedCommand(int effectId,
633 audio_session_t sessionId,
634 bool suspended);
Mikhail Naganov88b30d22020-03-09 19:43:13 +0000635 void audioModulesUpdateCommand();
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700636 void routingChangedCommand();
Eric Laurented726cc2021-07-01 14:26:41 +0200637 void updateUidStatesCommand();
Eric Laurent81dd0f52021-07-05 11:54:40 +0200638 void checkSpatializerCommand();
Eric Laurent15903592022-02-24 20:44:36 +0100639 void updateActiveSpatializerTracksCommand();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000640 void volRangeInitReqCommand();
Eric Laurent15903592022-02-24 20:44:36 +0100641
Eric Laurent951f4552014-05-20 10:48:17 -0700642 void insertCommand_l(AudioCommand *command, int delayMs = 0);
Mathias Agopian65ab4712010-07-14 17:59:35 -0700643 private:
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100644 class AudioCommandData;
645
Mathias Agopian65ab4712010-07-14 17:59:35 -0700646 // descriptor for requested tone playback event
Eric Laurent0ede8922014-05-09 18:04:42 -0700647 class AudioCommand: public RefBase {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700648
649 public:
650 AudioCommand()
Eric Laurent0ede8922014-05-09 18:04:42 -0700651 : mCommand(-1), mStatus(NO_ERROR), mWaitStatus(false) {}
Mathias Agopian65ab4712010-07-14 17:59:35 -0700652
653 void dump(char* buffer, size_t size);
654
Eric Laurentdcd4ab12018-06-29 17:45:13 -0700655 int mCommand; // SET_VOLUME, SET_PARAMETERS...
Mathias Agopian65ab4712010-07-14 17:59:35 -0700656 nsecs_t mTime; // time stamp
Andy Hung79eacdb2023-11-30 19:34:24 -0800657 audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioCommand_Mutex};
658 audio_utils::condition_variable mCond; // condition for status return
Mathias Agopian65ab4712010-07-14 17:59:35 -0700659 status_t mStatus; // command status
660 bool mWaitStatus; // true if caller is waiting for status
Eric Laurent0ede8922014-05-09 18:04:42 -0700661 sp<AudioCommandData> mParam; // command specific parameter data
Mathias Agopian65ab4712010-07-14 17:59:35 -0700662 };
663
Eric Laurent0ede8922014-05-09 18:04:42 -0700664 class AudioCommandData: public RefBase {
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100665 public:
666 virtual ~AudioCommandData() {}
667 protected:
668 AudioCommandData() {}
669 };
670
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100671 class VolumeData : public AudioCommandData {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700672 public:
Glenn Kastenfff6d712012-01-12 16:38:12 -0800673 audio_stream_type_t mStream;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700674 float mVolume;
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800675 audio_io_handle_t mIO;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700676 };
677
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100678 class ParametersData : public AudioCommandData {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700679 public:
Glenn Kasten72ef00d2012-01-17 11:09:42 -0800680 audio_io_handle_t mIO;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700681 String8 mKeyValuePairs;
682 };
683
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100684 class VoiceVolumeData : public AudioCommandData {
Mathias Agopian65ab4712010-07-14 17:59:35 -0700685 public:
686 float mVolume;
687 };
688
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100689 class StopOutputData : public AudioCommandData {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800690 public:
Eric Laurentd7fe0862018-07-14 16:48:01 -0700691 audio_port_handle_t mPortId;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800692 };
693
Jesper Tragardh48412dc2014-03-24 14:12:43 +0100694 class ReleaseOutputData : public AudioCommandData {
Eric Laurentbfb1b832013-01-07 09:53:42 -0800695 public:
Eric Laurentd7fe0862018-07-14 16:48:01 -0700696 audio_port_handle_t mPortId;
Eric Laurentbfb1b832013-01-07 09:53:42 -0800697 };
698
Eric Laurent951f4552014-05-20 10:48:17 -0700699 class CreateAudioPatchData : public AudioCommandData {
700 public:
701 struct audio_patch mPatch;
702 audio_patch_handle_t mHandle;
703 };
704
705 class ReleaseAudioPatchData : public AudioCommandData {
706 public:
707 audio_patch_handle_t mHandle;
708 };
709
François Gaffiecfe17322018-11-07 13:41:29 +0100710 class AudioVolumeGroupData : public AudioCommandData {
711 public:
712 volume_group_t mGroup;
713 int mFlags;
714 };
715
Eric Laurente1715a42014-05-20 11:30:42 -0700716 class SetAudioPortConfigData : public AudioCommandData {
717 public:
718 struct audio_port_config mConfig;
719 };
720
Jean-Michel Trivide801052015-04-14 19:10:14 -0700721 class DynPolicyMixStateUpdateData : public AudioCommandData {
722 public:
723 String8 mRegId;
724 int32_t mState;
725 };
726
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800727 class RecordingConfigurationUpdateData : public AudioCommandData {
728 public:
729 int mEvent;
Jean-Michel Triviac4e4292016-12-22 11:39:31 -0800730 record_client_info_t mClientInfo;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -0800731 struct audio_config_base mClientConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -0800732 std::vector<effect_descriptor_t> mClientEffects;
Jean-Michel Trivi7281aa92016-02-17 15:33:40 -0800733 struct audio_config_base mDeviceConfig;
Eric Laurenta9f86652018-11-28 17:23:11 -0800734 std::vector<effect_descriptor_t> mEffects;
Jean-Michel Trivi8c7cf3b2016-02-25 17:08:24 -0800735 audio_patch_handle_t mPatchHandle;
Eric Laurenta9f86652018-11-28 17:23:11 -0800736 audio_source_t mSource;
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800737 };
738
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700739 class SetEffectSuspendedData : public AudioCommandData {
740 public:
741 int mEffectId;
742 audio_session_t mSessionId;
743 bool mSuspended;
744 };
745
Andy Hung79eacdb2023-11-30 19:34:24 -0800746 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kCommandThread_Mutex};
747 audio_utils::condition_variable mWaitWorkCV;
Eric Laurent0ede8922014-05-09 18:04:42 -0700748 Vector < sp<AudioCommand> > mAudioCommands; // list of pending commands
Eric Laurent0ede8922014-05-09 18:04:42 -0700749 sp<AudioCommand> mLastCommand; // last processed command (used by dump)
Mathias Agopian65ab4712010-07-14 17:59:35 -0700750 String8 mName; // string used by wake lock fo delayed commands
Eric Laurentbfb1b832013-01-07 09:53:42 -0800751 wp<AudioPolicyService> mService;
Mathias Agopian65ab4712010-07-14 17:59:35 -0700752 };
753
Atneya Nair5b1ed642023-06-23 14:43:37 -0700754 private:
Eric Laurentdce54a12014-03-10 12:19:46 -0700755 class AudioPolicyClient : public AudioPolicyClientInterface
756 {
757 public:
Chih-Hung Hsiehe964d4e2016-08-09 14:31:32 -0700758 explicit AudioPolicyClient(AudioPolicyService *service) : mAudioPolicyService(service) {}
Eric Laurentdce54a12014-03-10 12:19:46 -0700759 virtual ~AudioPolicyClient() {}
760
Mikhail Naganovffd97712023-05-03 17:45:36 -0700761 virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig *config);
762
Eric Laurentdce54a12014-03-10 12:19:46 -0700763 //
764 // Audio HW module functions
765 //
766
767 // loads a HW module.
768 virtual audio_module_handle_t loadHwModule(const char *name);
769
770 //
771 // Audio output Control functions
772 //
773
774 // opens an audio output with the requested parameters. The parameter values can indicate to use the default values
775 // in case the audio policy manager has no specific requirements for the output being opened.
776 // When the function returns, the parameter values reflect the actual values used by the audio hardware output stream.
777 // The audio policy manager can check if the proposed parameters are suitable or not and act accordingly.
Eric Laurentcf2c0212014-07-25 16:20:43 -0700778 virtual status_t openOutput(audio_module_handle_t module,
779 audio_io_handle_t *output,
Eric Laurentf1f22e72021-07-13 14:04:14 +0200780 audio_config_t *halConfig,
781 audio_config_base_t *mixerConfig,
jiabin43810402019-10-24 14:58:31 -0700782 const sp<DeviceDescriptorBase>& device,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700783 uint32_t *latencyMs,
784 audio_output_flags_t flags);
Eric Laurentdce54a12014-03-10 12:19:46 -0700785 // creates a special output that is duplicated to the two outputs passed as arguments. The duplication is performed by
786 // a special mixer thread in the AudioFlinger.
787 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, audio_io_handle_t output2);
788 // closes the output stream
789 virtual status_t closeOutput(audio_io_handle_t output);
790 // suspends the output. When an output is suspended, the corresponding audio hardware output stream is placed in
791 // standby and the AudioTracks attached to the mixer thread are still processed but the output mix is discarded.
792 virtual status_t suspendOutput(audio_io_handle_t output);
793 // restores a suspended output.
794 virtual status_t restoreOutput(audio_io_handle_t output);
795
796 //
797 // Audio input Control functions
798 //
799
800 // opens an audio input
801 virtual audio_io_handle_t openInput(audio_module_handle_t module,
Eric Laurentcf2c0212014-07-25 16:20:43 -0700802 audio_io_handle_t *input,
803 audio_config_t *config,
804 audio_devices_t *devices,
805 const String8& address,
806 audio_source_t source,
Glenn Kastenec40d282014-07-15 15:31:26 -0700807 audio_input_flags_t flags);
Eric Laurentdce54a12014-03-10 12:19:46 -0700808 // closes an audio input
809 virtual status_t closeInput(audio_io_handle_t input);
810 //
811 // misc control functions
812 //
813
814 // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes
815 // for each output (destination device) it is attached to.
816 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0);
817
Eric Laurentdce54a12014-03-10 12:19:46 -0700818 // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface.
819 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0);
820 // function enabling to receive proprietary informations directly from audio hardware interface to audio policy manager.
821 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys);
822
Eric Laurentdce54a12014-03-10 12:19:46 -0700823 // set down link audio volume.
824 virtual status_t setVoiceVolume(float volume, int delayMs = 0);
825
826 // move effect to the specified output
Glenn Kastend848eb42016-03-08 13:42:11 -0800827 virtual status_t moveEffects(audio_session_t session,
Eric Laurentdce54a12014-03-10 12:19:46 -0700828 audio_io_handle_t srcOutput,
829 audio_io_handle_t dstOutput);
830
Eric Laurentb20cf7d2019-04-05 19:37:34 -0700831 void setEffectSuspended(int effectId,
832 audio_session_t sessionId,
833 bool suspended) override;
834
Eric Laurent951f4552014-05-20 10:48:17 -0700835 /* Create a patch between several source and sink ports */
836 virtual status_t createAudioPatch(const struct audio_patch *patch,
837 audio_patch_handle_t *handle,
838 int delayMs);
839
840 /* Release a patch */
841 virtual status_t releaseAudioPatch(audio_patch_handle_t handle,
842 int delayMs);
843
Eric Laurente1715a42014-05-20 11:30:42 -0700844 /* Set audio port configuration */
845 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs);
846
Eric Laurentb52c1522014-05-20 11:27:36 -0700847 virtual void onAudioPortListUpdate();
848 virtual void onAudioPatchListUpdate();
Jean-Michel Trivide801052015-04-14 19:10:14 -0700849 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800850 virtual void onRecordingConfigurationUpdate(int event,
Eric Laurenta9f86652018-11-28 17:23:11 -0800851 const record_client_info_t *clientInfo,
852 const audio_config_base_t *clientConfig,
853 std::vector<effect_descriptor_t> clientEffects,
854 const audio_config_base_t *deviceConfig,
855 std::vector<effect_descriptor_t> effects,
856 audio_patch_handle_t patchHandle,
857 audio_source_t source);
Eric Laurentb52c1522014-05-20 11:27:36 -0700858
François Gaffiecfe17322018-11-07 13:41:29 +0100859 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags);
860
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700861 virtual void onRoutingUpdated();
862
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000863 virtual void onVolumeRangeInitRequest();
864
Glenn Kasteneeecb982016-02-26 10:44:04 -0800865 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use);
Eric Laurentde3f8392014-07-27 18:38:22 -0700866
Ytai Ben-Tsvi74cd6b02019-10-25 10:06:40 -0700867 void setSoundTriggerCaptureState(bool active) override;
868
jiabinb4fed192020-09-22 14:45:40 -0700869 status_t getAudioPort(struct audio_port_v7 *port) override;
870
jiabin10a03f12021-05-07 23:46:28 +0000871 status_t updateSecondaryOutputs(
872 const TrackSecondaryOutputsMap& trackSecondaryOutputs) override;
873
Mikhail Naganov516d3982022-02-01 23:53:59 +0000874 status_t setDeviceConnectedState(
jiabinc0048632023-04-27 22:04:31 +0000875 const struct audio_port_v7 *port, media::DeviceConnectedState state) override;
Mikhail Naganov516d3982022-02-01 23:53:59 +0000876
jiabinc44b3462022-12-08 12:52:31 -0800877 status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) override;
878
jiabin12537fc2023-10-12 17:56:08 +0000879 status_t getAudioMixPort(const struct audio_port_v7 *devicePort,
880 struct audio_port_v7 *port) override;
881
Eric Laurentdce54a12014-03-10 12:19:46 -0700882 private:
883 AudioPolicyService *mAudioPolicyService;
884 };
885
Eric Laurentb52c1522014-05-20 11:27:36 -0700886 // --- Notification Client ---
887 class NotificationClient : public IBinder::DeathRecipient {
888 public:
889 NotificationClient(const sp<AudioPolicyService>& service,
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800890 const sp<media::IAudioPolicyServiceClient>& client,
luochaojiang908c7d72018-06-21 14:58:04 +0800891 uid_t uid, pid_t pid);
Eric Laurentb52c1522014-05-20 11:27:36 -0700892 virtual ~NotificationClient();
893
Jean-Michel Trivide801052015-04-14 19:10:14 -0700894 void onAudioPortListUpdate();
895 void onAudioPatchListUpdate();
Eric Laurenta9f86652018-11-28 17:23:11 -0800896 void onDynamicPolicyMixStateUpdate(const String8& regId,
897 int32_t state);
François Gaffiecfe17322018-11-07 13:41:29 +0100898 void onAudioVolumeGroupChanged(volume_group_t group, int flags);
Jean-Michel Trivi2f4fe9f2015-12-04 16:20:59 -0800899 void onRecordingConfigurationUpdate(
Eric Laurenta9f86652018-11-28 17:23:11 -0800900 int event,
901 const record_client_info_t *clientInfo,
902 const audio_config_base_t *clientConfig,
903 std::vector<effect_descriptor_t> clientEffects,
904 const audio_config_base_t *deviceConfig,
905 std::vector<effect_descriptor_t> effects,
906 audio_patch_handle_t patchHandle,
907 audio_source_t source);
Jean-Michel Trivi9a6b9ad2020-10-22 16:46:43 -0700908 void onRoutingUpdated();
Jean-Michel Trivi78f2b302022-04-15 18:18:41 +0000909 void onVolumeRangeInitRequest();
Eric Laurente8726fe2015-06-26 09:39:24 -0700910 void setAudioPortCallbacksEnabled(bool enabled);
François Gaffiecfe17322018-11-07 13:41:29 +0100911 void setAudioVolumeGroupCallbacksEnabled(bool enabled);
Eric Laurentb52c1522014-05-20 11:27:36 -0700912
luochaojiang908c7d72018-06-21 14:58:04 +0800913 uid_t uid() {
914 return mUid;
915 }
916
Eric Laurentb52c1522014-05-20 11:27:36 -0700917 // IBinder::DeathRecipient
918 virtual void binderDied(const wp<IBinder>& who);
919
920 private:
921 NotificationClient(const NotificationClient&);
922 NotificationClient& operator = (const NotificationClient&);
923
Ytai Ben-Tsvi7e7a79d2020-12-15 16:48:16 -0800924 const wp<AudioPolicyService> mService;
925 const uid_t mUid;
926 const pid_t mPid;
927 const sp<media::IAudioPolicyServiceClient> mAudioPolicyServiceClient;
928 bool mAudioPortCallbacksEnabled;
929 bool mAudioVolumeGroupCallbacksEnabled;
Eric Laurentb52c1522014-05-20 11:27:36 -0700930 };
931
Atneya Nair5b1ed642023-06-23 14:43:37 -0700932 public:
Eric Laurentd7fe0862018-07-14 16:48:01 -0700933 class AudioClient : public virtual RefBase {
934 public:
935 AudioClient(const audio_attributes_t attributes,
Philip P. Moltmannbda45752020-07-17 16:41:18 -0700936 const audio_io_handle_t io,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000937 const AttributionSourceState& attributionSource,
Eric Laurent5ada82e2019-08-29 17:53:54 -0700938 const audio_session_t session, audio_port_handle_t portId,
939 const audio_port_handle_t deviceId) :
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000940 attributes(attributes), io(io), attributionSource(
941 attributionSource), session(session), portId(portId),
942 deviceId(deviceId), active(false) {}
Eric Laurentd7fe0862018-07-14 16:48:01 -0700943 ~AudioClient() override = default;
944
945
946 const audio_attributes_t attributes; // source, flags ...
947 const audio_io_handle_t io; // audio HAL stream IO handle
Eric Laurent0d13fea2022-11-04 17:12:08 +0100948 const AttributionSourceState attributionSource; //client attributionsource
Eric Laurentd7fe0862018-07-14 16:48:01 -0700949 const audio_session_t session; // audio session ID
Eric Laurent5ada82e2019-08-29 17:53:54 -0700950 const audio_port_handle_t portId;
Eric Laurentd7fe0862018-07-14 16:48:01 -0700951 const audio_port_handle_t deviceId; // selected input device port ID
952 bool active; // Playback/Capture is active or inactive
953 };
Eric Laurented726cc2021-07-01 14:26:41 +0200954 private:
Eric Laurented726cc2021-07-01 14:26:41 +0200955
Eric Laurentd7fe0862018-07-14 16:48:01 -0700956
Eric Laurented726cc2021-07-01 14:26:41 +0200957
Eric Laurentd7fe0862018-07-14 16:48:01 -0700958 // --- AudioPlaybackClient ---
959 // Information about each registered AudioTrack client
960 // (between calls to getOutputForAttr() and releaseOutput())
961 class AudioPlaybackClient : public AudioClient {
962 public:
963 AudioPlaybackClient(const audio_attributes_t attributes,
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000964 const audio_io_handle_t io, AttributionSourceState attributionSource,
Eric Laurent5ada82e2019-08-29 17:53:54 -0700965 const audio_session_t session, audio_port_handle_t portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200966 audio_port_handle_t deviceId, audio_stream_type_t stream,
967 bool isSpatialized) :
Svet Ganov3e5f14f2021-05-13 22:51:08 +0000968 AudioClient(attributes, io, attributionSource, session, portId,
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200969 deviceId), stream(stream), isSpatialized(isSpatialized) {}
Eric Laurentd7fe0862018-07-14 16:48:01 -0700970 ~AudioPlaybackClient() override = default;
971
972 const audio_stream_type_t stream;
Eric Laurentb0a7bc92022-04-05 15:06:08 +0200973 const bool isSpatialized;
Eric Laurentfee19762018-01-29 18:44:13 -0800974 };
975
Eric Laurentbcfe5be2019-04-09 19:56:39 -0700976 void getPlaybackClientAndEffects(audio_port_handle_t portId,
977 sp<AudioPlaybackClient>& client,
978 sp<AudioPolicyEffects>& effects,
979 const char *context);
980
981
Eric Laurent10b71232018-04-13 18:14:44 -0700982 // A class automatically clearing and restoring binder caller identity inside
983 // a code block (scoped variable)
984 // Declare one systematically before calling AudioPolicyManager methods so that they are
985 // executed with the same level of privilege as audioserver process.
986 class AutoCallerClear {
987 public:
988 AutoCallerClear() :
989 mToken(IPCThreadState::self()->clearCallingIdentity()) {}
990 ~AutoCallerClear() {
991 IPCThreadState::self()->restoreCallingIdentity(mToken);
992 }
993
994 private:
995 const int64_t mToken;
996 };
997
Mathias Agopian65ab4712010-07-14 17:59:35 -0700998 // Internal dump utilities.
999 status_t dumpPermissionDenial(int fd);
Jaideep Sharmaba9053b2021-01-25 21:24:26 +05301000 void loadAudioPolicyManager();
1001 void unloadAudioPolicyManager();
Mathias Agopian65ab4712010-07-14 17:59:35 -07001002
Eric Laurent11094172022-04-05 18:27:42 +02001003 /**
1004 * Returns the number of active audio tracks on the specified output mixer.
1005 * The query can be specified to only include spatialized audio tracks or consider
1006 * all tracks.
1007 * @param output the I/O handle of the output mixer to consider
1008 * @param spatializedOnly true if only spatialized tracks should be considered
1009 * @return the number of active tracks.
1010 */
1011 size_t countActiveClientsOnOutput_l(
Andy Hung79eacdb2023-11-30 19:34:24 -08001012 audio_io_handle_t output, bool spatializedOnly = true) REQUIRES(mMutex);
Eric Laurent15903592022-02-24 20:44:36 +01001013
Andy Hung79eacdb2023-11-30 19:34:24 -08001014 mutable audio_utils::mutex mMutex{audio_utils::MutexOrder::kAudioPolicyService_Mutex};
1015 // prevents concurrent access to AudioPolicy manager functions changing
1016 // device connection state or routing.
1017 // mMutex protects AudioPolicyManager methods that can call into audio flinger
Haynes Mathew Georgebab7bf42015-10-30 18:02:23 -07001018 // and possibly back in to audio policy service and acquire mEffectsLock.
Glenn Kastene53b9ea2012-03-12 16:29:55 -07001019 sp<AudioCommandThread> mAudioCommandThread; // audio commands thread
Eric Laurentbfb1b832013-01-07 09:53:42 -08001020 sp<AudioCommandThread> mOutputCommandThread; // process stop and release output
Eric Laurentf269b8e2014-06-09 20:01:29 -07001021 AudioPolicyInterface *mAudioPolicyManager;
Eric Laurentdce54a12014-03-10 12:19:46 -07001022 AudioPolicyClient *mAudioPolicyClient;
Hayden Gomes524159d2019-12-23 14:41:47 -08001023 std::vector<audio_usage_t> mSupportedSystemUsages;
Eric Laurentdce54a12014-03-10 12:19:46 -07001024
Andy Hung79eacdb2023-11-30 19:34:24 -08001025 mutable audio_utils::mutex mNotificationClientsMutex{
1026 audio_utils::MutexOrder::kAudioPolicyService_NotificationClientsMutex};
Mikhail Naganov197d50a2020-04-30 22:37:43 +00001027 DefaultKeyedVector<int64_t, sp<NotificationClient>> mNotificationClients
Andy Hung79eacdb2023-11-30 19:34:24 -08001028 GUARDED_BY(mNotificationClientsMutex);
Shunkai Yaoeab8a7c2023-05-15 21:07:08 +00001029 // Manage all effects configured in audio_effects.conf
Andy Hung79eacdb2023-11-30 19:34:24 -08001030 // never hold AudioPolicyService::mMutex when calling AudioPolicyEffects methods as
Eric Laurent6c796322019-04-09 14:13:17 -07001031 // those can call back into AudioPolicyService methods and try to acquire the mutex
Andy Hung79eacdb2023-11-30 19:34:24 -08001032 sp<AudioPolicyEffects> mAudioPolicyEffects GUARDED_BY(mMutex);
1033 audio_mode_t mPhoneState GUARDED_BY(mMutex);
1034 uid_t mPhoneStateOwnerUid GUARDED_BY(mMutex);
Svet Ganovf4ddfef2018-01-16 07:37:58 -08001035
Andy Hung79eacdb2023-11-30 19:34:24 -08001036 sp<UidPolicy> mUidPolicy GUARDED_BY(mMutex);
1037 sp<SensorPrivacyPolicy> mSensorPrivacyPolicy GUARDED_BY(mMutex);
Michael Groovercfd28302018-12-11 19:16:46 -08001038
Mikhail Naganov197d50a2020-04-30 22:37:43 +00001039 DefaultKeyedVector<audio_port_handle_t, sp<AudioRecordClient>> mAudioRecordClients
Andy Hung79eacdb2023-11-30 19:34:24 -08001040 GUARDED_BY(mMutex);
Mikhail Naganov197d50a2020-04-30 22:37:43 +00001041 DefaultKeyedVector<audio_port_handle_t, sp<AudioPlaybackClient>> mAudioPlaybackClients
Andy Hung79eacdb2023-11-30 19:34:24 -08001042 GUARDED_BY(mMutex);
Kevin Rocard8be94972019-02-22 13:26:25 -08001043
1044 MediaPackageManager mPackageManager; // To check allowPlaybackCapture
Ytai Ben-Tsvi1ef846b2020-03-26 09:41:15 -07001045
1046 CaptureStateNotifier mCaptureStateNotifier;
Evan Severson241d9592021-01-08 12:16:02 -08001047
Andy Hung79eacdb2023-11-30 19:34:24 -08001048 // created in onFirstRef() and never cleared: does not need to be guarded by mMutex
Eric Laurent81dd0f52021-07-05 11:54:40 +02001049 sp<Spatializer> mSpatializer;
1050
Jaideep Sharmaba9053b2021-01-25 21:24:26 +05301051 void *mLibraryHandle = nullptr;
1052 CreateAudioPolicyManagerInstance mCreateAudioPolicyManager;
1053 DestroyAudioPolicyManagerInstance mDestroyAudioPolicyManager;
Eric Laurent0d13fea2022-11-04 17:12:08 +01001054 std::unique_ptr<media::UsecaseValidator> mUsecaseValidator;
Atneya Nair9f91a5e2024-05-09 16:25:05 -07001055 const sp<NativePermissionController> mPermissionController;
Mathias Agopian65ab4712010-07-14 17:59:35 -07001056};
1057
Mikhail Naganov1b2a7942017-12-08 10:18:09 -08001058} // namespace android
Mathias Agopian65ab4712010-07-14 17:59:35 -07001059
1060#endif // ANDROID_AUDIOPOLICYSERVICE_H