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 17 #ifndef ANDROID_AUDIOPOLICY_INTERFACE_H 18 #define ANDROID_AUDIOPOLICY_INTERFACE_H 19 20 #include <android/media/DeviceConnectedState.h> 21 #include <android/media/TrackInternalMuteInfo.h> 22 #include <android/media/audio/common/AudioConfigBase.h> 23 #include <android/media/audio/common/AudioMMapPolicyInfo.h> 24 #include <android/media/audio/common/AudioMMapPolicyType.h> 25 #include <android/media/GetInputForAttrResponse.h> 26 #include <android/content/AttributionSourceState.h> 27 #include <error/BinderResult.h> 28 #include <media/AudioCommonTypes.h> 29 #include <media/AudioContainers.h> 30 #include <media/AudioDeviceTypeAddr.h> 31 #include <media/AudioPolicy.h> 32 #include <media/AudioSystem.h> 33 #include <media/DeviceDescriptorBase.h> 34 #include <utils/String8.h> 35 36 namespace android { 37 38 using content::AttributionSourceState; 39 40 // ---------------------------------------------------------------------------- 41 42 // The AudioPolicyInterface and AudioPolicyClientInterface classes define the communication 43 // interfaces between the platform specific audio policy manager and Android generic audio policy 44 // manager. 45 // The platform specific audio policy manager must implement methods of the AudioPolicyInterface 46 // class. 47 // This implementation makes use of the AudioPolicyClientInterface to control the activity and 48 // configuration of audio input and output streams. 49 // 50 // The platform specific audio policy manager is in charge of the audio routing and volume control 51 // policies for a given platform. 52 // The main roles of this module are: 53 // - keep track of current system state (removable device connections, phone state, 54 // user requests...). 55 // System state changes and user actions are notified to audio policy manager with methods of the 56 // AudioPolicyInterface. 57 // - process getOutput() queries received when AudioTrack objects are created: Those queries 58 // return a handler on an output that has been selected, configured and opened by the audio 59 // policy manager and that must be used by the AudioTrack when registering to the AudioFlinger 60 // with the createTrack() method. 61 // When the AudioTrack object is released, a putOutput() query is received and the audio policy 62 // manager can decide to close or reconfigure the output depending on other streams using this 63 // output and current system state. 64 // - similarly process getInput() and putInput() queries received from AudioRecord objects and 65 // configure audio inputs. 66 // - process volume control requests: the stream volume is converted from an index value 67 // (received from UI) to a float value applicable to each output as a function of platform 68 // specificsettings and current output route (destination device). It also make sure that streams 69 // are not muted if not allowed (e.g. camera shutter sound in some countries). 70 // 71 // The platform specific audio policy manager is provided as a shared library by platform vendors 72 // (as for libaudio.so) and is linked with libaudioflinger.so 73 // 74 // NOTE: by convention, the implementation of the AudioPolicyInterface in AudioPolicyManager does 75 // not have to perform any nullptr check on input arguments: The caller of this API is 76 // AudioPolicyService running in the same process and in charge of validating arguments received 77 // from incoming binder calls before calling AudioPolicyManager. 78 79 // Audio Policy Manager Interface 80 class AudioPolicyInterface 81 { 82 83 public: 84 typedef enum { 85 API_INPUT_INVALID = -1, 86 API_INPUT_LEGACY = 0,// e.g. audio recording from a microphone 87 API_INPUT_MIX_CAPTURE,// used for "remote submix" legacy mode (no DAP), 88 // capture of the media to play it remotely 89 API_INPUT_MIX_EXT_POLICY_REROUTE,// used for platform audio rerouting, where mixes are 90 // handled by external and dynamically installed 91 // policies which reroute audio mixes 92 API_INPUT_MIX_PUBLIC_CAPTURE_PLAYBACK, // used for playback capture with a MediaProjection 93 API_INPUT_TELEPHONY_RX, // used for capture from telephony RX path 94 } input_type_t; 95 96 typedef enum { 97 API_OUTPUT_INVALID = -1, 98 API_OUTPUT_LEGACY = 0,// e.g. audio playing to speaker 99 API_OUT_MIX_PLAYBACK, // used for "remote submix" playback of audio from remote source 100 // to local capture 101 API_OUTPUT_TELEPHONY_TX, // used for playback to telephony TX path 102 } output_type_t; 103 104 public: ~AudioPolicyInterface()105 virtual ~AudioPolicyInterface() {} 106 // 107 // configuration functions 108 // 109 110 // Informs APM that new HAL modules are available. This typically happens 111 // due to registration of an audio HAL service. 112 virtual void onNewAudioModulesAvailable() = 0; 113 114 // indicate a change in device connection status 115 virtual status_t setDeviceConnectionState(audio_policy_dev_state_t state, 116 const android::media::audio::common::AudioPort& port, 117 audio_format_t encodedFormat) = 0; 118 // retrieve a device connection status 119 virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, 120 const char *device_address) = 0; 121 // indicate a change in device configuration 122 virtual status_t handleDeviceConfigChange(audio_devices_t device, 123 const char *device_address, 124 const char *device_name, 125 audio_format_t encodedFormat) = 0; 126 // indicate a change in phone state. Valid phones states are defined by audio_mode_t 127 virtual void setPhoneState(audio_mode_t state) = 0; 128 // force using a specific device category for the specified usage 129 virtual void setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) = 0; 130 // retrieve current device category forced for a given usage 131 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0; 132 // set a system property (e.g. camera sound always audible) 133 virtual void setSystemProperty(const char* property, const char* value) = 0; 134 // check proper initialization 135 virtual status_t initCheck() = 0; 136 137 // 138 // Audio routing query functions 139 // 140 141 // request an output appropriate for playback of the supplied stream type and parameters 142 virtual audio_io_handle_t getOutput(audio_stream_type_t stream) = 0; 143 virtual status_t getOutputForAttr(const audio_attributes_t *attr, 144 audio_io_handle_t *output, 145 audio_session_t session, 146 audio_stream_type_t *stream, 147 const AttributionSourceState& attributionSource, 148 audio_config_t *config, 149 audio_output_flags_t *flags, 150 DeviceIdVector *selectedDeviceIds, 151 audio_port_handle_t *portId, 152 std::vector<audio_io_handle_t> *secondaryOutputs, 153 output_type_t *outputType, 154 bool *isSpatialized, 155 bool *isBitPerfect, 156 float *volume, 157 bool *muted) = 0; 158 // indicates to the audio policy manager that the output starts being used by corresponding 159 // stream. 160 virtual status_t startOutput(audio_port_handle_t portId) = 0; 161 // indicates to the audio policy manager that the output stops being used by corresponding 162 // stream. 163 virtual status_t stopOutput(audio_port_handle_t portId) = 0; 164 // releases the output, return true if the output descriptor is reopened. 165 virtual bool releaseOutput(audio_port_handle_t portId) = 0; 166 167 // Request an input appropriate for record from the supplied device with supplied parameters. 168 // attr -- attributes for the requested record 169 // requestedInput -- input only for MMAP mode where an input is re-used, otherwise output param 170 // requestedDeviceId, config, flags -- additional params for matching 171 // riid, session, attributionSource -- params which encapsulate client info to associate with 172 // this input 173 // 174 // On most errors, return a Status describing the error in the error object. 175 // However, in cases where an appropriate device cannot be found for a config, the error side of 176 // the unexpected will contain a suggested config. 177 virtual base::expected<media::GetInputForAttrResponse, 178 std::variant<binder::Status, media::audio::common::AudioConfigBase>> 179 getInputForAttr(audio_attributes_t attributes, 180 audio_io_handle_t requestedInput, 181 audio_port_handle_t requestedDeviceId, 182 audio_config_base_t config, 183 audio_input_flags_t flags, 184 audio_unique_id_t riid, 185 audio_session_t session, 186 const AttributionSourceState& attributionSource) = 0; 187 // indicates to the audio policy manager that the input starts being used. 188 virtual status_t startInput(audio_port_handle_t portId) = 0; 189 // indicates to the audio policy manager that the input stops being used. 190 virtual status_t stopInput(audio_port_handle_t portId) = 0; 191 // releases the input. 192 virtual void releaseInput(audio_port_handle_t portId) = 0; 193 194 // 195 // volume control functions 196 // 197 198 // notifies the audio policy manager that the absolute volume mode is enabled/disabled on 199 // the passed device. Also specifies the stream that is controlling the absolute volume. 200 virtual status_t setDeviceAbsoluteVolumeEnabled(audio_devices_t device, 201 const char *address, 202 bool enabled, 203 audio_stream_type_t streamToDriveAbs) = 0; 204 // initialises stream volume conversion parameters by specifying volume index range. 205 virtual void initStreamVolume(audio_stream_type_t stream, 206 int indexMin, 207 int indexMax) = 0; 208 209 // sets the new stream volume at a level corresponding to the supplied index for the 210 // supplied device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME means 211 // setting volume for all devices 212 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 213 int index, 214 bool muted, 215 audio_devices_t device) = 0; 216 217 // retrieve current volume index for the specified stream and the 218 // specified device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT_FOR_VOLUME means 219 // querying the volume of the active device. 220 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 221 int *index, 222 audio_devices_t device) = 0; 223 224 virtual status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, 225 int index, 226 bool muted, 227 audio_devices_t device) = 0; 228 virtual status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, 229 int &index, 230 audio_devices_t device) = 0; 231 232 virtual status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, 233 int &index) = 0; 234 235 virtual status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, 236 int &index) = 0; 237 238 // return the strategy corresponding to a given stream type 239 virtual product_strategy_t getStrategyForStream(audio_stream_type_t stream) = 0; 240 241 // retrieves the list of enabled output devices for the given audio attributes 242 virtual status_t getDevicesForAttributes(const audio_attributes_t &attr, 243 AudioDeviceTypeAddrVector *devices, 244 bool forVolume) = 0; 245 246 // Audio effect management 247 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0; 248 virtual status_t registerEffect(const effect_descriptor_t *desc, 249 audio_io_handle_t io, 250 product_strategy_t strategy, 251 int session, 252 int id) = 0; 253 virtual status_t unregisterEffect(int id) = 0; 254 virtual status_t setEffectEnabled(int id, bool enabled) = 0; 255 virtual status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io) = 0; 256 257 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0; 258 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, 259 uint32_t inPastMs = 0) const = 0; 260 virtual bool isSourceActive(audio_source_t source) const = 0; 261 262 //dump state 263 virtual status_t dump(int fd) = 0; 264 265 virtual status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t flags) = 0; 266 virtual audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& offloadInfo) = 0; 267 virtual bool isDirectOutputSupported(const audio_config_base_t& config, 268 const audio_attributes_t& attributes) = 0; 269 270 virtual status_t listAudioPorts(audio_port_role_t role, 271 audio_port_type_t type, 272 unsigned int *num_ports, 273 struct audio_port_v7 *ports, 274 unsigned int *generation) = 0; 275 virtual status_t listDeclaredDevicePorts(media::AudioPortRole role, 276 std::vector<media::AudioPortFw>* result) = 0; 277 virtual status_t getAudioPort(struct audio_port_v7 *port) = 0; 278 virtual status_t createAudioPatch(const struct audio_patch *patch, 279 audio_patch_handle_t *handle, 280 uid_t uid) = 0; 281 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 282 uid_t uid) = 0; 283 virtual status_t listAudioPatches(unsigned int *num_patches, 284 struct audio_patch *patches, 285 unsigned int *generation) = 0; 286 virtual status_t setAudioPortConfig(const struct audio_port_config *config) = 0; 287 virtual void releaseResourcesForUid(uid_t uid) = 0; 288 289 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 290 audio_io_handle_t *ioHandle, 291 audio_devices_t *device) = 0; 292 293 virtual status_t releaseSoundTriggerSession(audio_session_t session) = 0; 294 295 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes) = 0; 296 virtual status_t unregisterPolicyMixes(Vector<AudioMix> mixes) = 0; 297 virtual status_t getRegisteredPolicyMixes(std::vector<AudioMix>& mixes) = 0; 298 299 virtual status_t updatePolicyMix( 300 const AudioMix& mix, 301 const std::vector<AudioMixMatchCriterion>& updatedCriteria) = 0; 302 303 virtual status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices) 304 = 0; 305 virtual status_t removeUidDeviceAffinities(uid_t uid) = 0; 306 307 virtual status_t setUserIdDeviceAffinities(int userId, 308 const AudioDeviceTypeAddrVector& devices) = 0; 309 virtual status_t removeUserIdDeviceAffinities(int userId) = 0; 310 311 virtual status_t startAudioSource(const struct audio_port_config *source, 312 const audio_attributes_t *attributes, 313 audio_port_handle_t *portId, 314 uid_t uid) = 0; 315 virtual status_t stopAudioSource(audio_port_handle_t portId) = 0; 316 317 virtual status_t setMasterMono(bool mono) = 0; 318 virtual status_t getMasterMono(bool *mono) = 0; 319 320 virtual float getStreamVolumeDB( 321 audio_stream_type_t stream, int index, audio_devices_t device) = 0; 322 323 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, 324 audio_format_t *surroundFormats, 325 bool *surroundFormatsEnabled) = 0; 326 327 virtual status_t getReportedSurroundFormats(unsigned int *numSurroundFormats, 328 audio_format_t *surroundFormats) = 0; 329 330 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled) = 0; 331 332 virtual bool isHapticPlaybackSupported() = 0; 333 334 virtual bool isUltrasoundSupported() = 0; 335 336 virtual bool isHotwordStreamSupported(bool lookbackAudio) = 0; 337 338 virtual status_t getHwOffloadFormatsSupportedForBluetoothMedia( 339 audio_devices_t device, std::vector<audio_format_t> *formats) = 0; 340 341 virtual void setAppState(audio_port_handle_t portId, app_state_t state) = 0; 342 343 virtual status_t listAudioProductStrategies(AudioProductStrategyVector &strategies) = 0; 344 345 virtual status_t getProductStrategyFromAudioAttributes( 346 const audio_attributes_t &aa, product_strategy_t &productStrategy, 347 bool fallbackOnDefault) = 0; 348 349 virtual status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups) = 0; 350 351 virtual status_t getVolumeGroupFromAudioAttributes( 352 const audio_attributes_t &aa, volume_group_t &volumeGroup, bool fallbackOnDefault) = 0; 353 354 virtual bool isCallScreenModeSupported() = 0; 355 356 virtual status_t setDevicesRoleForStrategy(product_strategy_t strategy, 357 device_role_t role, 358 const AudioDeviceTypeAddrVector &devices) = 0; 359 360 virtual status_t removeDevicesRoleForStrategy(product_strategy_t strategy, 361 device_role_t role, 362 const AudioDeviceTypeAddrVector &devices) = 0; 363 364 virtual status_t clearDevicesRoleForStrategy(product_strategy_t strategy, 365 device_role_t role) = 0; 366 367 virtual status_t getDevicesForRoleAndStrategy(product_strategy_t strategy, 368 device_role_t role, 369 AudioDeviceTypeAddrVector &devices) = 0; 370 371 virtual status_t setDevicesRoleForCapturePreset(audio_source_t audioSource, 372 device_role_t role, 373 const AudioDeviceTypeAddrVector &devices) = 0; 374 375 virtual status_t addDevicesRoleForCapturePreset(audio_source_t audioSource, 376 device_role_t role, 377 const AudioDeviceTypeAddrVector &devices) = 0; 378 379 virtual status_t removeDevicesRoleForCapturePreset( 380 audio_source_t audioSource, device_role_t role, 381 const AudioDeviceTypeAddrVector& devices) = 0; 382 383 virtual status_t clearDevicesRoleForCapturePreset(audio_source_t audioSource, 384 device_role_t role) = 0; 385 386 virtual status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource, 387 device_role_t role, 388 AudioDeviceTypeAddrVector &devices) = 0; 389 390 /** 391 * Queries if some kind of spatialization will be performed if the audio playback context 392 * described by the provided arguments is present. 393 * The context is made of: 394 * - The audio attributes describing the playback use case. 395 * - The audio configuration describing the audio format, channels, sampling rate ... 396 * - The devices describing the sink audio device selected for playback. 397 * All arguments are optional and only the specified arguments are used to match against 398 * supported criteria. For instance, supplying no argument will tell if spatialization is 399 * supported or not in general. 400 * @param attr audio attributes describing the playback use case 401 * @param config audio configuration describing the audio format, channels, sampling rate... 402 * @param devices the sink audio device selected for playback 403 * @return true if spatialization is enabled for this context, 404 * false otherwise 405 */ 406 virtual bool canBeSpatialized(const audio_attributes_t *attr, 407 const audio_config_t *config, 408 const AudioDeviceTypeAddrVector &devices) const = 0; 409 410 /** 411 * Opens a specialized spatializer output if supported by the platform. 412 * If several spatializer output profiles exist, the one supporting the sink device 413 * corresponding to the provided audio attributes will be selected. 414 * Only one spatializer output stream can be opened at a time and an error is returned 415 * if one already exists. 416 * @param config audio format, channel mask and sampling rate to be used as the mixer 417 * configuration for the spatializer mixer created. 418 * @param attr audio attributes describing the playback use case that will drive the 419 * sink device selection 420 * @param output the IO handle of the output opened 421 * @return NO_ERROR if an output was opened, INVALID_OPERATION or BAD_VALUE otherwise 422 */ 423 virtual status_t getSpatializerOutput(const audio_config_base_t *config, 424 const audio_attributes_t *attr, 425 audio_io_handle_t *output) = 0; 426 427 /** 428 * Closes a previously opened specialized spatializer output. 429 * @param output the IO handle of the output to close. 430 * @return NO_ERROR if an output was closed, INVALID_OPERATION or BAD_VALUE otherwise 431 */ 432 virtual status_t releaseSpatializerOutput(audio_io_handle_t output) = 0; 433 434 /** 435 * Query how the direct playback is currently supported on the device. 436 * @param attr audio attributes describing the playback use case 437 * @param config audio configuration for the playback 438 * @param directMode out: a set of flags describing how the direct playback is currently 439 * supported on the device 440 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE, PERMISSION_DENIED 441 * in case of error. 442 */ 443 virtual audio_direct_mode_t getDirectPlaybackSupport(const audio_attributes_t *attr, 444 const audio_config_t *config) = 0; 445 446 // retrieves the list of available direct audio profiles for the given audio attributes 447 virtual status_t getDirectProfilesForAttributes(const audio_attributes_t* attr, 448 AudioProfileVector& audioProfiles) = 0; 449 450 virtual status_t getSupportedMixerAttributes( 451 audio_port_handle_t portId, std::vector<audio_mixer_attributes_t>& mixerAttrs) = 0; 452 virtual status_t setPreferredMixerAttributes( 453 const audio_attributes_t* attr, 454 audio_port_handle_t portId, 455 uid_t uid, 456 const audio_mixer_attributes_t* mixerAttributes) = 0; 457 virtual status_t getPreferredMixerAttributes(const audio_attributes_t* attr, 458 audio_port_handle_t portId, 459 audio_mixer_attributes_t* mixerAttributes) = 0; 460 virtual status_t clearPreferredMixerAttributes(const audio_attributes_t* attr, 461 audio_port_handle_t portId, 462 uid_t uid) = 0; 463 464 virtual status_t getMmapPolicyInfos( 465 media::audio::common::AudioMMapPolicyType policyType, 466 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) = 0; 467 virtual status_t getMmapPolicyForDevice( 468 media::audio::common::AudioMMapPolicyType policyType, 469 media::audio::common::AudioMMapPolicyInfo *policyInfo) = 0; 470 }; 471 472 // Audio Policy client Interface 473 class AudioPolicyClientInterface 474 { 475 public: ~AudioPolicyClientInterface()476 virtual ~AudioPolicyClientInterface() {} 477 478 virtual status_t getAudioPolicyConfig(media::AudioPolicyConfig *config) = 0; 479 480 // 481 // Audio HW module functions 482 // 483 484 // loads a HW module. 485 virtual audio_module_handle_t loadHwModule(const char *name) = 0; 486 487 // 488 // Audio output Control functions 489 // 490 491 // opens an audio output with the requested parameters. The parameter values can indicate to 492 // use the default values in case the audio policy manager has no specific requirements for the 493 // output being opened. 494 // When the function returns, the parameter values reflect the actual values used by the audio 495 // hardware output stream. 496 // The audio policy manager can check if the proposed parameters are suitable or not and act 497 // accordingly. 498 virtual status_t openOutput(audio_module_handle_t module, 499 audio_io_handle_t *output, 500 audio_config_t *halConfig, 501 audio_config_base_t *mixerConfig, 502 const sp<DeviceDescriptorBase>& device, 503 uint32_t *latencyMs, 504 audio_output_flags_t *flags, 505 audio_attributes_t audioAttributes) = 0; 506 // creates a special output that is duplicated to the two outputs passed as arguments. 507 // The duplication is performed by a special mixer thread in the AudioFlinger. 508 virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, 509 audio_io_handle_t output2) = 0; 510 // closes the output stream 511 virtual status_t closeOutput(audio_io_handle_t output) = 0; 512 // suspends the output. When an output is suspended, the corresponding audio hardware output 513 // stream is placed in standby and the AudioTracks attached to the mixer thread are still 514 // processed but the output mix is discarded. 515 virtual status_t suspendOutput(audio_io_handle_t output) = 0; 516 // restores a suspended output. 517 virtual status_t restoreOutput(audio_io_handle_t output) = 0; 518 519 // 520 // Audio input Control functions 521 // 522 523 // opens an audio input 524 virtual status_t openInput(audio_module_handle_t module, 525 audio_io_handle_t *input, 526 audio_config_t *config, 527 audio_devices_t *device, 528 const String8& address, 529 audio_source_t source, 530 audio_input_flags_t flags) = 0; 531 // closes an audio input 532 virtual status_t closeInput(audio_io_handle_t input) = 0; 533 // 534 // misc control functions 535 // 536 537 // set a stream volume for a particular output. For the same user setting, a given stream type 538 // can have different volumes 539 // for each output (destination device) it is attached to. 540 virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, bool muted, 541 audio_io_handle_t output, int delayMs = 0) = 0; 542 /** 543 * Set volume for given AudioTrack port ids for a particular output. 544 * For the same user setting, a given volume group and associated output port id 545 * can have different volumes for each output (destination device) it is attached to. 546 * @param ports to consider 547 * @param volume to apply 548 * @param muted to apply 549 * @param output to consider 550 * @param delayMs to use 551 * @return NO_ERROR if successful 552 */ 553 virtual status_t setPortsVolume(const std::vector<audio_port_handle_t>& ports, float volume, 554 bool muted, audio_io_handle_t output, int delayMs = 0) = 0; 555 556 // function enabling to send proprietary informations directly from audio policy manager to 557 // audio hardware interface. 558 virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, 559 int delayMs = 0) = 0; 560 // function enabling to receive proprietary informations directly from audio hardware interface 561 // to audio policy manager. 562 virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys) = 0; 563 564 // set down link audio volume. 565 virtual status_t setVoiceVolume(float volume, int delayMs = 0) = 0; 566 567 // move effect to the specified output 568 virtual status_t moveEffects(audio_session_t session, 569 audio_io_handle_t srcOutput, 570 audio_io_handle_t dstOutput) = 0; 571 572 virtual void setEffectSuspended(int effectId, 573 audio_session_t sessionId, 574 bool suspended) = 0; 575 576 /* Create a patch between several source and sink ports */ 577 virtual status_t createAudioPatch(const struct audio_patch *patch, 578 audio_patch_handle_t *handle, 579 int delayMs) = 0; 580 581 /* Release a patch */ 582 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 583 int delayMs) = 0; 584 585 /* Set audio port configuration */ 586 virtual status_t setAudioPortConfig(const struct audio_port_config *config, int delayMs) = 0; 587 588 virtual void onAudioPortListUpdate() = 0; 589 590 virtual void onAudioPatchListUpdate() = 0; 591 592 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0; 593 594 virtual audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use) = 0; 595 596 virtual void onDynamicPolicyMixStateUpdate(String8 regId, int32_t state) = 0; 597 598 virtual void onRecordingConfigurationUpdate(int event, 599 const record_client_info_t *clientInfo, 600 const audio_config_base_t *clientConfig, 601 std::vector<effect_descriptor_t> clientEffects, 602 const audio_config_base_t *deviceConfig, 603 std::vector<effect_descriptor_t> effects, 604 audio_patch_handle_t patchHandle, 605 audio_source_t source) = 0; 606 607 virtual void onRoutingUpdated() = 0; 608 609 // Used to notify AudioService that an error was encountering when reading 610 // the volume ranges, and that they should be re-initialized 611 virtual void onVolumeRangeInitRequest() = 0; 612 613 // Used to notify the sound trigger module that an audio capture is about to 614 // take place. This should typically result in any active recognition 615 // sessions to be preempted on modules that do not support sound trigger 616 // recognition concurrently with audio capture. 617 virtual void setSoundTriggerCaptureState(bool active) = 0; 618 619 virtual status_t getAudioPort(struct audio_port_v7 *port) = 0; 620 621 virtual status_t updateSecondaryOutputs( 622 const TrackSecondaryOutputsMap& trackSecondaryOutputs) = 0; 623 624 virtual status_t setDeviceConnectedState(const struct audio_port_v7 *port, 625 media::DeviceConnectedState state) = 0; 626 627 virtual status_t invalidateTracks(const std::vector<audio_port_handle_t>& portIds) = 0; 628 629 // Get the attributes of the mix port when connecting to the given device port. 630 virtual status_t getAudioMixPort(const struct audio_port_v7 *devicePort, 631 struct audio_port_v7 *mixPort) = 0; 632 633 virtual status_t setTracksInternalMute( 634 const std::vector<media::TrackInternalMuteInfo>& tracksInternalMute) = 0; 635 636 virtual status_t getMmapPolicyInfos( 637 media::audio::common::AudioMMapPolicyType policyType, 638 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos) = 0; 639 640 enum class MixType { 641 // e.g. audio recording from a microphone 642 NONE = 0, 643 // used for "remote submix" legacy mode (no DAP), capture of the media to play it remotely 644 CAPTURE, 645 // used for platform audio rerouting, where mixes are handled by external and dynamically 646 // installed policies which reroute audio mixes 647 EXT_POLICY_REROUTE, 648 // used for playback capture with a MediaProjection 649 PUBLIC_CAPTURE_PLAYBACK, 650 // used for capture from telephony RX path 651 TELEPHONY_RX_CAPTURE, 652 }; 653 654 struct PermissionReqs { 655 media::audio::common::AudioSource source; 656 MixType mixType; 657 uint32_t virtualDeviceId; 658 // Flag based validation 659 bool isHotword; 660 bool isCallRedir; 661 }; 662 663 virtual error::BinderResult<bool> checkPermissionForInput(const AttributionSourceState& attr, 664 const PermissionReqs& req) = 0; 665 }; 666 667 // These are the signatures of createAudioPolicyManager/destroyAudioPolicyManager 668 // methods respectively, expected by AudioPolicyService, needs to be exposed by 669 // libaudiopolicymanagercustom. 670 using CreateAudioPolicyManagerInstance = 671 AudioPolicyInterface* (*)(AudioPolicyClientInterface*); 672 using DestroyAudioPolicyManagerInstance = void (*)(AudioPolicyInterface*); 673 674 } // namespace android 675 676 #endif // ANDROID_AUDIOPOLICY_INTERFACE_H 677