Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 1 | /* |
| 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 | |
Eric Laurent | dce54a1 | 2014-03-10 12:19:46 -0700 | [diff] [blame] | 17 | #ifndef ANDROID_AUDIOPOLICY_INTERFACE_H |
| 18 | #define ANDROID_AUDIOPOLICY_INTERFACE_H |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 19 | |
jiabin | 10a03f1 | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 20 | #include <media/AudioCommonTypes.h> |
Mikhail Naganov | 5478fc1 | 2021-07-08 16:13:29 -0700 | [diff] [blame] | 21 | #include <media/AudioContainers.h> |
jiabin | 05b5edd | 2019-11-04 14:10:42 -0800 | [diff] [blame] | 22 | #include <media/AudioDeviceTypeAddr.h> |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 23 | #include <media/AudioSystem.h> |
Eric Laurent | baac183 | 2014-12-01 17:52:59 -0800 | [diff] [blame] | 24 | #include <media/AudioPolicy.h> |
jiabin | 4381040 | 2019-10-24 14:58:31 -0700 | [diff] [blame] | 25 | #include <media/DeviceDescriptorBase.h> |
Svet Ganov | 3e5f14f | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 26 | #include <android/content/AttributionSourceState.h> |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 27 | #include <utils/String8.h> |
| 28 | |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 29 | namespace android { |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 30 | |
Svet Ganov | 3e5f14f | 2021-05-13 22:51:08 +0000 | [diff] [blame] | 31 | using content::AttributionSourceState; |
| 32 | |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 33 | // ---------------------------------------------------------------------------- |
| 34 | |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 35 | // The AudioPolicyInterface and AudioPolicyClientInterface classes define the communication |
| 36 | // interfaces between the platform specific audio policy manager and Android generic audio policy |
| 37 | // manager. |
| 38 | // The platform specific audio policy manager must implement methods of the AudioPolicyInterface |
| 39 | // class. |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 40 | // This implementation makes use of the AudioPolicyClientInterface to control the activity and |
| 41 | // configuration of audio input and output streams. |
| 42 | // |
| 43 | // The platform specific audio policy manager is in charge of the audio routing and volume control |
| 44 | // policies for a given platform. |
| 45 | // The main roles of this module are: |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 46 | // - keep track of current system state (removable device connections, phone state, |
| 47 | // user requests...). |
| 48 | // System state changes and user actions are notified to audio policy manager with methods of the |
| 49 | // AudioPolicyInterface. |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 50 | // - process getOutput() queries received when AudioTrack objects are created: Those queries |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 51 | // return a handler on an output that has been selected, configured and opened by the audio |
| 52 | // policy manager and that must be used by the AudioTrack when registering to the AudioFlinger |
| 53 | // with the createTrack() method. |
| 54 | // When the AudioTrack object is released, a putOutput() query is received and the audio policy |
| 55 | // manager can decide to close or reconfigure the output depending on other streams using this |
| 56 | // output and current system state. |
| 57 | // - similarly process getInput() and putInput() queries received from AudioRecord objects and |
| 58 | // configure audio inputs. |
| 59 | // - process volume control requests: the stream volume is converted from an index value |
| 60 | // (received from UI) to a float value applicable to each output as a function of platform |
| 61 | // specificsettings and current output route (destination device). It also make sure that streams |
| 62 | // are not muted if not allowed (e.g. camera shutter sound in some countries). |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 63 | // |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 64 | // The platform specific audio policy manager is provided as a shared library by platform vendors |
| 65 | // (as for libaudio.so) and is linked with libaudioflinger.so |
| 66 | // |
| 67 | // NOTE: by convention, the implementation of the AudioPolicyInterface in AudioPolicyManager does |
| 68 | // not have to perform any nullptr check on input arguments: The caller of this API is |
| 69 | // AudioPolicyService running in the same process and in charge of validating arguments received |
| 70 | // from incoming binder calls before calling AudioPolicyManager. |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 71 | |
| 72 | // Audio Policy Manager Interface |
| 73 | class AudioPolicyInterface |
| 74 | { |
| 75 | |
| 76 | public: |
Jean-Michel Trivi | 97bb33f | 2014-12-12 16:23:43 -0800 | [diff] [blame] | 77 | typedef enum { |
| 78 | API_INPUT_INVALID = -1, |
| 79 | API_INPUT_LEGACY = 0,// e.g. audio recording from a microphone |
Kevin Rocard | 25f9b05 | 2019-02-27 15:08:54 -0800 | [diff] [blame] | 80 | API_INPUT_MIX_CAPTURE,// used for "remote submix" legacy mode (no DAP), |
| 81 | // capture of the media to play it remotely |
Jean-Michel Trivi | 97bb33f | 2014-12-12 16:23:43 -0800 | [diff] [blame] | 82 | API_INPUT_MIX_EXT_POLICY_REROUTE,// used for platform audio rerouting, where mixes are |
| 83 | // handled by external and dynamically installed |
| 84 | // policies which reroute audio mixes |
Kevin Rocard | 25f9b05 | 2019-02-27 15:08:54 -0800 | [diff] [blame] | 85 | API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK, // used for playback capture with a MediaProjection |
Eric Laurent | 82db269 | 2015-08-07 13:59:42 -0700 | [diff] [blame] | 86 | API_INPUT_TELEPHONY_RX, // used for capture from telephony RX path |
Jean-Michel Trivi | 97bb33f | 2014-12-12 16:23:43 -0800 | [diff] [blame] | 87 | } input_type_t; |
| 88 | |
Eric Laurent | 8a1095a | 2019-11-08 14:44:16 -0800 | [diff] [blame] | 89 | typedef enum { |
| 90 | API_OUTPUT_INVALID = -1, |
| 91 | API_OUTPUT_LEGACY = 0,// e.g. audio playing to speaker |
| 92 | API_OUT_MIX_PLAYBACK, // used for "remote submix" playback of audio from remote source |
| 93 | // to local capture |
| 94 | API_OUTPUT_TELEPHONY_TX, // used for playback to telephony TX path |
| 95 | } output_type_t; |
| 96 | |
Jean-Michel Trivi | 97bb33f | 2014-12-12 16:23:43 -0800 | [diff] [blame] | 97 | public: |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 98 | virtual ~AudioPolicyInterface() {} |
| 99 | // |
| 100 | // configuration functions |
| 101 | // |
| 102 | |
Mikhail Naganov | c0d0498 | 2020-03-02 21:02:28 +0000 | [diff] [blame] | 103 | // Informs APM that new HAL modules are available. This typically happens |
| 104 | // due to registration of an audio HAL service. |
| 105 | virtual void onNewAudioModulesAvailable() = 0; |
| 106 | |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 107 | // indicate a change in device connection status |
Nathalie Le Clair | 88fa275 | 2021-11-23 13:03:41 +0100 | [diff] [blame] | 108 | virtual status_t setDeviceConnectionState(audio_policy_dev_state_t state, |
| 109 | const android::media::audio::common::AudioPort& port, |
Aniket Kumar Lata | 4e46470 | 2019-01-10 23:38:46 -0800 | [diff] [blame] | 110 | audio_format_t encodedFormat) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 111 | // retrieve a device connection status |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 112 | virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 113 | const char *device_address) = 0; |
Pavlin Radoslavov | f862bc6 | 2016-12-26 18:57:22 -0800 | [diff] [blame] | 114 | // indicate a change in device configuration |
| 115 | virtual status_t handleDeviceConfigChange(audio_devices_t device, |
| 116 | const char *device_address, |
Aniket Kumar Lata | 4e46470 | 2019-01-10 23:38:46 -0800 | [diff] [blame] | 117 | const char *device_name, |
| 118 | audio_format_t encodedFormat) = 0; |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 119 | // indicate a change in phone state. Valid phones states are defined by audio_mode_t |
| 120 | virtual void setPhoneState(audio_mode_t state) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 121 | // force using a specific device category for the specified usage |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 122 | virtual void setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 123 | // retrieve current device category forced for a given usage |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 124 | virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 125 | // set a system property (e.g. camera sound always audible) |
| 126 | virtual void setSystemProperty(const char* property, const char* value) = 0; |
| 127 | // check proper initialization |
| 128 | virtual status_t initCheck() = 0; |
| 129 | |
| 130 | // |
| 131 | // Audio routing query functions |
| 132 | // |
| 133 | |
| 134 | // request an output appropriate for playback of the supplied stream type and parameters |
Eric Laurent | f4e6345 | 2017-11-06 19:31:46 +0000 | [diff] [blame] | 135 | virtual audio_io_handle_t getOutput(audio_stream_type_t stream) = 0; |
Eric Laurent | e83b55d | 2014-11-14 10:06:21 -0800 | [diff] [blame] | 136 | virtual status_t getOutputForAttr(const audio_attributes_t *attr, |
jiabin | f1c7397 | 2022-04-14 16:28:52 -0700 | [diff] [blame] | 137 | audio_io_handle_t *output, |
| 138 | audio_session_t session, |
| 139 | audio_stream_type_t *stream, |
Eric Laurent | 0d13fea | 2022-11-04 17:12:08 +0100 | [diff] [blame] | 140 | const AttributionSourceState& attributionSource, |
jiabin | f1c7397 | 2022-04-14 16:28:52 -0700 | [diff] [blame] | 141 | audio_config_t *config, |
| 142 | audio_output_flags_t *flags, |
| 143 | audio_port_handle_t *selectedDeviceId, |
| 144 | audio_port_handle_t *portId, |
| 145 | std::vector<audio_io_handle_t> *secondaryOutputs, |
| 146 | output_type_t *outputType, |
jiabin | c658e45 | 2022-10-21 20:52:21 +0000 | [diff] [blame] | 147 | bool *isSpatialized, |
| 148 | bool *isBitPerfect) = 0; |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 149 | // indicates to the audio policy manager that the output starts being used by corresponding |
| 150 | // stream. |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 151 | virtual status_t startOutput(audio_port_handle_t portId) = 0; |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 152 | // indicates to the audio policy manager that the output stops being used by corresponding |
| 153 | // stream. |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 154 | virtual status_t stopOutput(audio_port_handle_t portId) = 0; |
jiabin | bce0c1d | 2020-10-05 11:20:18 -0700 | [diff] [blame] | 155 | // releases the output, return true if the output descriptor is reopened. |
| 156 | virtual bool releaseOutput(audio_port_handle_t portId) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 157 | |
| 158 | // request an input appropriate for record from the supplied device with supplied parameters. |
Eric Laurent | caf7f48 | 2014-11-25 17:50:47 -0800 | [diff] [blame] | 159 | virtual status_t getInputForAttr(const audio_attributes_t *attr, |
| 160 | audio_io_handle_t *input, |
Mikhail Naganov | 2996f67 | 2019-04-18 12:29:59 -0700 | [diff] [blame] | 161 | audio_unique_id_t riid, |
Eric Laurent | caf7f48 | 2014-11-25 17:50:47 -0800 | [diff] [blame] | 162 | audio_session_t session, |
Eric Laurent | 0d13fea | 2022-11-04 17:12:08 +0100 | [diff] [blame] | 163 | const AttributionSourceState& attributionSource, |
jiabin | f1c7397 | 2022-04-14 16:28:52 -0700 | [diff] [blame] | 164 | audio_config_base_t *config, |
Jean-Michel Trivi | 97bb33f | 2014-12-12 16:23:43 -0800 | [diff] [blame] | 165 | audio_input_flags_t flags, |
Eric Laurent | 9ae8c59 | 2017-06-22 17:17:09 -0700 | [diff] [blame] | 166 | audio_port_handle_t *selectedDeviceId, |
Eric Laurent | 20b9ef0 | 2016-12-05 11:03:16 -0800 | [diff] [blame] | 167 | input_type_t *inputType, |
| 168 | audio_port_handle_t *portId) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 169 | // indicates to the audio policy manager that the input starts being used. |
Eric Laurent | 4eb58f1 | 2018-12-07 16:41:02 -0800 | [diff] [blame] | 170 | virtual status_t startInput(audio_port_handle_t portId) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 171 | // indicates to the audio policy manager that the input stops being used. |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 172 | virtual status_t stopInput(audio_port_handle_t portId) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 173 | // releases the input. |
Eric Laurent | 8fc147b | 2018-07-22 19:13:55 -0700 | [diff] [blame] | 174 | virtual void releaseInput(audio_port_handle_t portId) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 175 | |
| 176 | // |
| 177 | // volume control functions |
| 178 | // |
| 179 | |
| 180 | // initialises stream volume conversion parameters by specifying volume index range. |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 181 | virtual void initStreamVolume(audio_stream_type_t stream, |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 182 | int indexMin, |
| 183 | int indexMax) = 0; |
| 184 | |
| 185 | // sets the new stream volume at a level corresponding to the supplied index for the |
Eric Laurent | 5a2b629 | 2016-04-14 18:05:57 -0700 | [diff] [blame] | 186 | // supplied device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME means |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 187 | // setting volume for all devices |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 188 | virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 189 | int index, |
| 190 | audio_devices_t device) = 0; |
| 191 | |
| 192 | // retrieve current volume index for the specified stream and the |
Eric Laurent | 5a2b629 | 2016-04-14 18:05:57 -0700 | [diff] [blame] | 193 | // specified device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME means |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 194 | // querying the volume of the active device. |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 195 | virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 196 | int *index, |
| 197 | audio_devices_t device) = 0; |
| 198 | |
François Gaffie | cfe1732 | 2018-11-07 13:41:29 +0100 | [diff] [blame] | 199 | virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 200 | int index, |
| 201 | audio_devices_t device) = 0; |
| 202 | virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 203 | int &index, |
| 204 | audio_devices_t device) = 0; |
| 205 | |
| 206 | virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 207 | int &index) = 0; |
| 208 | |
| 209 | virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, |
| 210 | int &index) = 0; |
| 211 | |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 212 | // return the strategy corresponding to a given stream type |
Ytai Ben-Tsvi | 0a4904a | 2021-01-06 12:57:05 -0800 | [diff] [blame] | 213 | virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 214 | |
Jean-Michel Trivi | f41599b | 2020-01-07 14:22:08 -0800 | [diff] [blame] | 215 | // retrieves the list of enabled output devices for the given audio attributes |
| 216 | virtual status_t getDevicesForAttributes(const audio_attributes_t &attr, |
Andy Hung | 6d23c0f | 2022-02-16 09:37:15 -0800 | [diff] [blame] | 217 | AudioDeviceTypeAddrVector *devices, |
| 218 | bool forVolume) = 0; |
Jean-Michel Trivi | f41599b | 2020-01-07 14:22:08 -0800 | [diff] [blame] | 219 | |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 220 | // Audio effect management |
| 221 | virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0; |
| 222 | virtual status_t registerEffect(const effect_descriptor_t *desc, |
| 223 | audio_io_handle_t io, |
Ytai Ben-Tsvi | 0a4904a | 2021-01-06 12:57:05 -0800 | [diff] [blame] | 224 | product_strategy_t strategy, |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 225 | int session, |
| 226 | int id) = 0; |
| 227 | virtual status_t unregisterEffect(int id) = 0; |
| 228 | virtual status_t setEffectEnabled(int id, bool enabled) = 0; |
Eric Laurent | 6c79632 | 2019-04-09 14:13:17 -0700 | [diff] [blame] | 229 | virtual status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 230 | |
Eric Laurent | 3b73df7 | 2014-03-11 09:06:29 -0700 | [diff] [blame] | 231 | virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0; |
| 232 | virtual bool isStreamActiveRemotely(audio_stream_type_t stream, |
| 233 | uint32_t inPastMs = 0) const = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 234 | virtual bool isSourceActive(audio_source_t source) const = 0; |
| 235 | |
| 236 | //dump state |
| 237 | virtual status_t dump(int fd) = 0; |
| 238 | |
Kevin Rocard | b99cc75 | 2019-03-21 20:52:24 -0700 | [diff] [blame] | 239 | virtual status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) = 0; |
Eric Laurent | 90fe31c | 2020-11-26 20:06:35 +0100 | [diff] [blame] | 240 | virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& offloadInfo) = 0; |
Michael Chan | a94fbb2 | 2018-04-24 14:31:19 +1000 | [diff] [blame] | 241 | virtual bool isDirectOutputSupported(const audio_config_base_t& config, |
| 242 | const audio_attributes_t& attributes) = 0; |
Eric Laurent | 6a94d69 | 2014-05-20 11:18:06 -0700 | [diff] [blame] | 243 | |
| 244 | virtual status_t listAudioPorts(audio_port_role_t role, |
| 245 | audio_port_type_t type, |
| 246 | unsigned int *num_ports, |
jiabin | 19cdba5 | 2020-11-24 11:28:58 -0800 | [diff] [blame] | 247 | struct audio_port_v7 *ports, |
Eric Laurent | 6a94d69 | 2014-05-20 11:18:06 -0700 | [diff] [blame] | 248 | unsigned int *generation) = 0; |
jiabin | 19cdba5 | 2020-11-24 11:28:58 -0800 | [diff] [blame] | 249 | virtual status_t getAudioPort(struct audio_port_v7 *port) = 0; |
Eric Laurent | 6a94d69 | 2014-05-20 11:18:06 -0700 | [diff] [blame] | 250 | virtual status_t createAudioPatch(const struct audio_patch *patch, |
| 251 | audio_patch_handle_t *handle, |
| 252 | uid_t uid) = 0; |
| 253 | virtual status_t releaseAudioPatch(audio_patch_handle_t handle, |
| 254 | uid_t uid) = 0; |
| 255 | virtual status_t listAudioPatches(unsigned int *num_patches, |
| 256 | struct audio_patch *patches, |
| 257 | unsigned int *generation) = 0; |
| 258 | virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0; |
Eric Laurent | 8c7e6da | 2015-04-21 17:37:00 -0700 | [diff] [blame] | 259 | virtual void releaseResourcesForUid(uid_t uid) = 0; |
Eric Laurent | 6a94d69 | 2014-05-20 11:18:06 -0700 | [diff] [blame] | 260 | |
Eric Laurent | df3dc7e | 2014-07-27 18:39:40 -0700 | [diff] [blame] | 261 | virtual status_t acquireSoundTriggerSession(audio_session_t *session, |
| 262 | audio_io_handle_t *ioHandle, |
| 263 | audio_devices_t *device) = 0; |
| 264 | |
| 265 | virtual status_t releaseSoundTriggerSession(audio_session_t session) = 0; |
Eric Laurent | baac183 | 2014-12-01 17:52:59 -0800 | [diff] [blame] | 266 | |
Chih-Hung Hsieh | e964d4e | 2016-08-09 14:31:32 -0700 | [diff] [blame] | 267 | virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes) = 0; |
Eric Laurent | baac183 | 2014-12-01 17:52:59 -0800 | [diff] [blame] | 268 | virtual status_t unregisterPolicyMixes(Vector<AudioMix> mixes) = 0; |
Eric Laurent | 554a277 | 2015-04-10 11:29:24 -0700 | [diff] [blame] | 269 | |
jiabin | 6a02d53 | 2020-08-07 11:56:38 -0700 | [diff] [blame] | 270 | virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices) |
Jean-Michel Trivi | bda70da | 2018-12-19 07:30:15 -0800 | [diff] [blame] | 271 | = 0; |
| 272 | virtual status_t removeUidDeviceAffinities(uid_t uid) = 0; |
| 273 | |
Oscar Azucena | 90e7763 | 2019-11-27 17:12:28 -0800 | [diff] [blame] | 274 | virtual status_t setUserIdDeviceAffinities(int userId, |
jiabin | 6a02d53 | 2020-08-07 11:56:38 -0700 | [diff] [blame] | 275 | const AudioDeviceTypeAddrVector& devices) = 0; |
Oscar Azucena | 90e7763 | 2019-11-27 17:12:28 -0800 | [diff] [blame] | 276 | virtual status_t removeUserIdDeviceAffinities(int userId) = 0; |
| 277 | |
Eric Laurent | 554a277 | 2015-04-10 11:29:24 -0700 | [diff] [blame] | 278 | virtual status_t startAudioSource(const struct audio_port_config *source, |
| 279 | const audio_attributes_t *attributes, |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 280 | audio_port_handle_t *portId, |
Eric Laurent | d60560a | 2015-04-10 11:31:20 -0700 | [diff] [blame] | 281 | uid_t uid) = 0; |
Eric Laurent | 3e6c7e1 | 2018-07-27 17:09:23 -0700 | [diff] [blame] | 282 | virtual status_t stopAudioSource(audio_port_handle_t portId) = 0; |
Andy Hung | 2ddee19 | 2015-12-18 17:34:44 -0800 | [diff] [blame] | 283 | |
| 284 | virtual status_t setMasterMono(bool mono) = 0; |
| 285 | virtual status_t getMasterMono(bool *mono) = 0; |
Eric Laurent | ac9cef5 | 2017-06-09 15:46:26 -0700 | [diff] [blame] | 286 | |
| 287 | virtual float getStreamVolumeDB( |
| 288 | audio_stream_type_t stream, int index, audio_devices_t device) = 0; |
Svet Ganov | f4ddfef | 2018-01-16 07:37:58 -0800 | [diff] [blame] | 289 | |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 290 | virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, |
| 291 | audio_format_t *surroundFormats, |
Kriti Dang | 6537def | 2021-03-02 13:46:59 +0100 | [diff] [blame] | 292 | bool *surroundFormatsEnabled) = 0; |
| 293 | |
| 294 | virtual status_t getReportedSurroundFormats(unsigned int *numSurroundFormats, |
| 295 | audio_format_t *surroundFormats) = 0; |
| 296 | |
jiabin | 8177290 | 2018-04-02 17:52:27 -0700 | [diff] [blame] | 297 | virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) = 0; |
| 298 | |
jiabin | 6012f91 | 2018-11-02 17:06:30 -0700 | [diff] [blame] | 299 | virtual bool isHapticPlaybackSupported() = 0; |
| 300 | |
Carter Hsu | 325a8eb | 2022-01-19 19:56:51 +0800 | [diff] [blame] | 301 | virtual bool isUltrasoundSupported() = 0; |
| 302 | |
Patty | dd80758 | 2021-11-04 21:01:03 +0800 | [diff] [blame] | 303 | virtual status_t getHwOffloadFormatsSupportedForBluetoothMedia( |
| 304 | audio_devices_t device, std::vector<audio_format_t> *formats) = 0; |
Arun Mirpuri | 11029ad | 2018-12-19 20:45:19 -0800 | [diff] [blame] | 305 | |
Eric Laurent | 5ada82e | 2019-08-29 17:53:54 -0700 | [diff] [blame] | 306 | virtual void setAppState(audio_port_handle_t portId, app_state_t state) = 0; |
François Gaffie | d0ba9ed | 2018-11-05 11:50:42 +0100 | [diff] [blame] | 307 | |
| 308 | virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0; |
| 309 | |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 310 | virtual status_t getProductStrategyFromAudioAttributes( |
François Gaffie | 1e2b56f | 2022-04-01 14:34:29 +0200 | [diff] [blame] | 311 | const audio_attributes_t &aa, product_strategy_t &productStrategy, |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 312 | bool fallbackOnDefault) = 0; |
François Gaffie | 4b2018b | 2018-11-07 11:18:59 +0100 | [diff] [blame] | 313 | |
| 314 | virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0; |
| 315 | |
Francois Gaffie | 11b6592 | 2020-09-24 16:59:08 +0200 | [diff] [blame] | 316 | virtual status_t getVolumeGroupFromAudioAttributes( |
François Gaffie | 1e2b56f | 2022-04-01 14:34:29 +0200 | [diff] [blame] | 317 | const audio_attributes_t &aa, volume_group_t &volumeGroup, bool fallbackOnDefault) = 0; |
Eric Laurent | 8340e67 | 2019-11-06 11:01:08 -0800 | [diff] [blame] | 318 | |
| 319 | virtual bool isCallScreenModeSupported() = 0; |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 320 | |
jiabin | 0a48893 | 2020-08-07 17:32:40 -0700 | [diff] [blame] | 321 | virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy, |
| 322 | device_role_t role, |
| 323 | const AudioDeviceTypeAddrVector &devices) = 0; |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 324 | |
jiabin | 0a48893 | 2020-08-07 17:32:40 -0700 | [diff] [blame] | 325 | virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, |
Paul Wang | 5d7cdb5 | 2022-11-22 09:45:06 +0000 | [diff] [blame^] | 326 | device_role_t role, |
| 327 | const AudioDeviceTypeAddrVector &devices) = 0; |
Jean-Michel Trivi | 3085715 | 2019-11-01 11:04:15 -0700 | [diff] [blame] | 328 | |
Paul Wang | 5d7cdb5 | 2022-11-22 09:45:06 +0000 | [diff] [blame^] | 329 | virtual status_t clearDevicesRoleForStrategy(product_strategy_t strategy, |
| 330 | device_role_t role) = 0; |
jiabin | 0a48893 | 2020-08-07 17:32:40 -0700 | [diff] [blame] | 331 | |
| 332 | virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy, |
| 333 | device_role_t role, |
| 334 | AudioDeviceTypeAddrVector &devices) = 0; |
Jiabin Huang | 3b98d32 | 2020-09-03 17:54:16 +0000 | [diff] [blame] | 335 | |
| 336 | virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 337 | device_role_t role, |
| 338 | const AudioDeviceTypeAddrVector &devices) = 0; |
| 339 | |
| 340 | virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 341 | device_role_t role, |
| 342 | const AudioDeviceTypeAddrVector &devices) = 0; |
| 343 | |
| 344 | virtual status_t removeDevicesRoleForCapturePreset( |
| 345 | audio_source_t audioSource, device_role_t role, |
| 346 | const AudioDeviceTypeAddrVector& devices) = 0; |
| 347 | |
| 348 | virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource, |
| 349 | device_role_t role) = 0; |
| 350 | |
| 351 | virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource, |
| 352 | device_role_t role, |
| 353 | AudioDeviceTypeAddrVector &devices) = 0; |
Eric Laurent | 81dd0f5 | 2021-07-05 11:54:40 +0200 | [diff] [blame] | 354 | |
| 355 | /** |
| 356 | * Queries if some kind of spatialization will be performed if the audio playback context |
| 357 | * described by the provided arguments is present. |
| 358 | * The context is made of: |
| 359 | * - The audio attributes describing the playback use case. |
| 360 | * - The audio configuration describing the audio format, channels, sampling rate ... |
| 361 | * - The devices describing the sink audio device selected for playback. |
| 362 | * All arguments are optional and only the specified arguments are used to match against |
| 363 | * supported criteria. For instance, supplying no argument will tell if spatialization is |
| 364 | * supported or not in general. |
| 365 | * @param attr audio attributes describing the playback use case |
| 366 | * @param config audio configuration describing the audio format, channels, sampling rate... |
| 367 | * @param devices the sink audio device selected for playback |
| 368 | * @return true if spatialization is enabled for this context, |
| 369 | * false otherwise |
| 370 | */ |
| 371 | virtual bool canBeSpatialized(const audio_attributes_t *attr, |
| 372 | const audio_config_t *config, |
| 373 | const AudioDeviceTypeAddrVector &devices) const = 0; |
| 374 | |
| 375 | /** |
| 376 | * Opens a specialized spatializer output if supported by the platform. |
| 377 | * If several spatializer output profiles exist, the one supporting the sink device |
| 378 | * corresponding to the provided audio attributes will be selected. |
| 379 | * Only one spatializer output stream can be opened at a time and an error is returned |
| 380 | * if one already exists. |
| 381 | * @param config audio format, channel mask and sampling rate to be used as the mixer |
| 382 | * configuration for the spatializer mixer created. |
| 383 | * @param attr audio attributes describing the playback use case that will drive the |
| 384 | * sink device selection |
| 385 | * @param output the IO handle of the output opened |
| 386 | * @return NO_ERROR if an output was opened, INVALID_OPERATION or BAD_VALUE otherwise |
| 387 | */ |
| 388 | virtual status_t getSpatializerOutput(const audio_config_base_t *config, |
| 389 | const audio_attributes_t *attr, |
| 390 | audio_io_handle_t *output) = 0; |
| 391 | |
| 392 | /** |
| 393 | * Closes a previously opened specialized spatializer output. |
| 394 | * @param output the IO handle of the output to close. |
| 395 | * @return NO_ERROR if an output was closed, INVALID_OPERATION or BAD_VALUE otherwise |
| 396 | */ |
| 397 | virtual status_t releaseSpatializerOutput(audio_io_handle_t output) = 0; |
jiabin | 2b9d5a1 | 2021-12-10 01:06:29 +0000 | [diff] [blame] | 398 | |
| 399 | /** |
| 400 | * Query how the direct playback is currently supported on the device. |
| 401 | * @param attr audio attributes describing the playback use case |
| 402 | * @param config audio configuration for the playback |
| 403 | * @param directMode out: a set of flags describing how the direct playback is currently |
| 404 | * supported on the device |
| 405 | * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE, PERMISSION_DENIED |
| 406 | * in case of error. |
| 407 | */ |
| 408 | virtual audio_direct_mode_t getDirectPlaybackSupport(const audio_attributes_t *attr, |
| 409 | const audio_config_t *config) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 410 | |
Dorin Drimus | f2196d8 | 2022-01-03 12:11:18 +0100 | [diff] [blame] | 411 | // retrieves the list of available direct audio profiles for the given audio attributes |
| 412 | virtual status_t getDirectProfilesForAttributes(const audio_attributes_t* attr, |
| 413 | AudioProfileVector& audioProfiles) = 0; |
jiabin | a84c3d3 | 2022-12-02 18:59:55 +0000 | [diff] [blame] | 414 | |
| 415 | virtual status_t getSupportedMixerAttributes( |
| 416 | audio_port_handle_t portId, std::vector<audio_mixer_attributes_t>& mixerAttrs) = 0; |
| 417 | virtual status_t setPreferredMixerAttributes( |
| 418 | const audio_attributes_t* attr, |
| 419 | audio_port_handle_t portId, |
| 420 | uid_t uid, |
| 421 | const audio_mixer_attributes_t* mixerAttributes) = 0; |
| 422 | virtual status_t getPreferredMixerAttributes(const audio_attributes_t* attr, |
| 423 | audio_port_handle_t portId, |
| 424 | audio_mixer_attributes_t* mixerAttributes) = 0; |
| 425 | virtual status_t clearPreferredMixerAttributes(const audio_attributes_t* attr, |
| 426 | audio_port_handle_t portId, |
| 427 | uid_t uid) = 0; |
Dorin Drimus | f2196d8 | 2022-01-03 12:11:18 +0100 | [diff] [blame] | 428 | }; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 429 | |
| 430 | // Audio Policy client Interface |
| 431 | class AudioPolicyClientInterface |
| 432 | { |
| 433 | public: |
| 434 | virtual ~AudioPolicyClientInterface() {} |
| 435 | |
| 436 | // |
| 437 | // Audio HW module functions |
| 438 | // |
| 439 | |
| 440 | // loads a HW module. |
| 441 | virtual audio_module_handle_t loadHwModule(const char *name) = 0; |
| 442 | |
| 443 | // |
| 444 | // Audio output Control functions |
| 445 | // |
| 446 | |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 447 | // opens an audio output with the requested parameters. The parameter values can indicate to |
| 448 | // use the default values in case the audio policy manager has no specific requirements for the |
| 449 | // output being opened. |
| 450 | // When the function returns, the parameter values reflect the actual values used by the audio |
| 451 | // hardware output stream. |
| 452 | // The audio policy manager can check if the proposed parameters are suitable or not and act |
| 453 | // accordingly. |
Eric Laurent | cf2c021 | 2014-07-25 16:20:43 -0700 | [diff] [blame] | 454 | virtual status_t openOutput(audio_module_handle_t module, |
| 455 | audio_io_handle_t *output, |
Eric Laurent | f1f22e7 | 2021-07-13 14:04:14 +0200 | [diff] [blame] | 456 | audio_config_t *halConfig, |
| 457 | audio_config_base_t *mixerConfig, |
jiabin | 4381040 | 2019-10-24 14:58:31 -0700 | [diff] [blame] | 458 | const sp<DeviceDescriptorBase>& device, |
Eric Laurent | cf2c021 | 2014-07-25 16:20:43 -0700 | [diff] [blame] | 459 | uint32_t *latencyMs, |
| 460 | audio_output_flags_t flags) = 0; |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 461 | // creates a special output that is duplicated to the two outputs passed as arguments. |
| 462 | // The duplication is performed by a special mixer thread in the AudioFlinger. |
| 463 | virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, |
| 464 | audio_io_handle_t output2) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 465 | // closes the output stream |
| 466 | virtual status_t closeOutput(audio_io_handle_t output) = 0; |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 467 | // suspends the output. When an output is suspended, the corresponding audio hardware output |
| 468 | // stream is placed in standby and the AudioTracks attached to the mixer thread are still |
| 469 | // processed but the output mix is discarded. |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 470 | virtual status_t suspendOutput(audio_io_handle_t output) = 0; |
| 471 | // restores a suspended output. |
| 472 | virtual status_t restoreOutput(audio_io_handle_t output) = 0; |
| 473 | |
| 474 | // |
| 475 | // Audio input Control functions |
| 476 | // |
| 477 | |
| 478 | // opens an audio input |
Eric Laurent | cf2c021 | 2014-07-25 16:20:43 -0700 | [diff] [blame] | 479 | virtual status_t openInput(audio_module_handle_t module, |
| 480 | audio_io_handle_t *input, |
| 481 | audio_config_t *config, |
| 482 | audio_devices_t *device, |
| 483 | const String8& address, |
| 484 | audio_source_t source, |
| 485 | audio_input_flags_t flags) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 486 | // closes an audio input |
| 487 | virtual status_t closeInput(audio_io_handle_t input) = 0; |
| 488 | // |
| 489 | // misc control functions |
| 490 | // |
| 491 | |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 492 | // set a stream volume for a particular output. For the same user setting, a given stream type |
| 493 | // can have different volumes |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 494 | // for each output (destination device) it is attached to. |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 495 | virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, |
| 496 | audio_io_handle_t output, int delayMs = 0) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 497 | |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 498 | // function enabling to send proprietary informations directly from audio policy manager to |
| 499 | // audio hardware interface. |
| 500 | virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, |
| 501 | int delayMs = 0) = 0; |
| 502 | // function enabling to receive proprietary informations directly from audio hardware interface |
| 503 | // to audio policy manager. |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 504 | virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) = 0; |
| 505 | |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 506 | // set down link audio volume. |
| 507 | virtual status_t setVoiceVolume(float volume, int delayMs = 0) = 0; |
| 508 | |
| 509 | // move effect to the specified output |
Glenn Kasten | d848eb4 | 2016-03-08 13:42:11 -0800 | [diff] [blame] | 510 | virtual status_t moveEffects(audio_session_t session, |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 511 | audio_io_handle_t srcOutput, |
| 512 | audio_io_handle_t dstOutput) = 0; |
| 513 | |
Eric Laurent | b20cf7d | 2019-04-05 19:37:34 -0700 | [diff] [blame] | 514 | virtual void setEffectSuspended(int effectId, |
| 515 | audio_session_t sessionId, |
| 516 | bool suspended) = 0; |
| 517 | |
Eric Laurent | 951f455 | 2014-05-20 10:48:17 -0700 | [diff] [blame] | 518 | /* Create a patch between several source and sink ports */ |
| 519 | virtual status_t createAudioPatch(const struct audio_patch *patch, |
| 520 | audio_patch_handle_t *handle, |
| 521 | int delayMs) = 0; |
| 522 | |
| 523 | /* Release a patch */ |
| 524 | virtual status_t releaseAudioPatch(audio_patch_handle_t handle, |
| 525 | int delayMs) = 0; |
| 526 | |
Eric Laurent | e1715a4 | 2014-05-20 11:30:42 -0700 | [diff] [blame] | 527 | /* Set audio port configuration */ |
| 528 | virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs) = 0; |
| 529 | |
Eric Laurent | b52c152 | 2014-05-20 11:27:36 -0700 | [diff] [blame] | 530 | virtual void onAudioPortListUpdate() = 0; |
| 531 | |
| 532 | virtual void onAudioPatchListUpdate() = 0; |
Eric Laurent | de3f839 | 2014-07-27 18:38:22 -0700 | [diff] [blame] | 533 | |
François Gaffie | cfe1732 | 2018-11-07 13:41:29 +0100 | [diff] [blame] | 534 | virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0; |
| 535 | |
Glenn Kasten | f0c6d7d | 2016-02-26 10:44:04 -0800 | [diff] [blame] | 536 | virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) = 0; |
Jean-Michel Trivi | de80105 | 2015-04-14 19:10:14 -0700 | [diff] [blame] | 537 | |
| 538 | virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) = 0; |
Jean-Michel Trivi | 2f4fe9f | 2015-12-04 16:20:59 -0800 | [diff] [blame] | 539 | |
Jean-Michel Trivi | ac4e429 | 2016-12-22 11:39:31 -0800 | [diff] [blame] | 540 | virtual void onRecordingConfigurationUpdate(int event, |
Eric Laurent | a9f8665 | 2018-11-28 17:23:11 -0800 | [diff] [blame] | 541 | const record_client_info_t *clientInfo, |
| 542 | const audio_config_base_t *clientConfig, |
| 543 | std::vector<effect_descriptor_t> clientEffects, |
| 544 | const audio_config_base_t *deviceConfig, |
| 545 | std::vector<effect_descriptor_t> effects, |
| 546 | audio_patch_handle_t patchHandle, |
| 547 | audio_source_t source) = 0; |
Ytai Ben-Tsvi | 74cd6b0 | 2019-10-25 10:06:40 -0700 | [diff] [blame] | 548 | |
Jean-Michel Trivi | 9a6b9ad | 2020-10-22 16:46:43 -0700 | [diff] [blame] | 549 | virtual void onRoutingUpdated() = 0; |
| 550 | |
Jean-Michel Trivi | 78f2b30 | 2022-04-15 18:18:41 +0000 | [diff] [blame] | 551 | // Used to notify AudioService that an error was encountering when reading |
| 552 | // the volume ranges, and that they should be re-initialized |
| 553 | virtual void onVolumeRangeInitRequest() = 0; |
| 554 | |
Ytai Ben-Tsvi | 74cd6b0 | 2019-10-25 10:06:40 -0700 | [diff] [blame] | 555 | // Used to notify the sound trigger module that an audio capture is about to |
| 556 | // take place. This should typically result in any active recognition |
| 557 | // sessions to be preempted on modules that do not support sound trigger |
| 558 | // recognition concurrently with audio capture. |
| 559 | virtual void setSoundTriggerCaptureState(bool active) = 0; |
jiabin | b4fed19 | 2020-09-22 14:45:40 -0700 | [diff] [blame] | 560 | |
| 561 | virtual status_t getAudioPort(struct audio_port_v7 *port) = 0; |
jiabin | 10a03f1 | 2021-05-07 23:46:28 +0000 | [diff] [blame] | 562 | |
| 563 | virtual status_t updateSecondaryOutputs( |
| 564 | const TrackSecondaryOutputsMap& trackSecondaryOutputs) = 0; |
Mikhail Naganov | 516d398 | 2022-02-01 23:53:59 +0000 | [diff] [blame] | 565 | |
| 566 | virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port, bool connected) = 0; |
jiabin | c44b346 | 2022-12-08 12:52:31 -0800 | [diff] [blame] | 567 | |
| 568 | virtual status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) = 0; |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 569 | }; |
| 570 | |
Jaideep Sharma | ba9053b | 2021-01-25 21:24:26 +0530 | [diff] [blame] | 571 | // These are the signatures of createAudioPolicyManager/destroyAudioPolicyManager |
| 572 | // methods respectively, expected by AudioPolicyService, needs to be exposed by |
| 573 | // libaudiopolicymanagercustom. |
Eric Laurent | 0eb2f4a | 2021-10-05 13:57:18 +0200 | [diff] [blame] | 574 | using CreateAudioPolicyManagerInstance = |
| 575 | AudioPolicyInterface* (*)(AudioPolicyClientInterface*); |
Jaideep Sharma | ba9053b | 2021-01-25 21:24:26 +0530 | [diff] [blame] | 576 | using DestroyAudioPolicyManagerInstance = void (*)(AudioPolicyInterface*); |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 577 | |
Mikhail Naganov | 1b2a794 | 2017-12-08 10:18:09 -0800 | [diff] [blame] | 578 | } // namespace android |
Eric Laurent | e552edb | 2014-03-10 17:42:56 -0700 | [diff] [blame] | 579 | |
Eric Laurent | dce54a1 | 2014-03-10 12:19:46 -0700 | [diff] [blame] | 580 | #endif // ANDROID_AUDIOPOLICY_INTERFACE_H |