1 /* 2 * Copyright (C) 2008 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_AUDIOSYSTEM_H_ 18 #define ANDROID_AUDIOSYSTEM_H_ 19 20 #include <sys/types.h> 21 22 #include <mutex> 23 #include <set> 24 #include <vector> 25 26 #include <android/content/AttributionSourceState.h> 27 #include <android/media/AudioPolicyConfig.h> 28 #include <android/media/AudioPortFw.h> 29 #include <android/media/AudioVibratorInfo.h> 30 #include <android/media/BnAudioFlingerClient.h> 31 #include <android/media/BnAudioPolicyServiceClient.h> 32 #include <android/media/EffectDescriptor.h> 33 #include <android/media/INativeAudioVolumeGroupCallback.h> 34 #include <android/media/INativeSpatializerCallback.h> 35 #include <android/media/ISoundDose.h> 36 #include <android/media/ISoundDoseCallback.h> 37 #include <android/media/ISpatializer.h> 38 #include <android/media/MicrophoneInfoFw.h> 39 #include <android/media/RecordClientInfo.h> 40 #include <android/media/audio/common/AudioConfigBase.h> 41 #include <android/media/audio/common/AudioMMapPolicyInfo.h> 42 #include <android/media/audio/common/AudioMMapPolicyType.h> 43 #include <android/media/audio/common/AudioPort.h> 44 #include <media/AidlConversionUtil.h> 45 #include <media/AudioContainers.h> 46 #include <media/AudioDeviceTypeAddr.h> 47 #include <media/AudioPolicy.h> 48 #include <media/AudioProductStrategy.h> 49 #include <media/AudioVolumeGroup.h> 50 #include <media/AudioIoDescriptor.h> 51 #include <system/audio.h> 52 #include <system/audio_effect.h> 53 #include <system/audio_policy.h> 54 #include <utils/Errors.h> 55 #include <utils/Mutex.h> 56 57 using android::content::AttributionSourceState; 58 59 namespace android { 60 61 struct record_client_info { 62 audio_unique_id_t riid; 63 uid_t uid; 64 audio_session_t session; 65 audio_source_t source; 66 audio_port_handle_t port_id; 67 bool silenced; 68 }; 69 70 typedef struct record_client_info record_client_info_t; 71 72 // AIDL conversion functions. 73 ConversionResult<record_client_info_t> 74 aidl2legacy_RecordClientInfo_record_client_info_t(const media::RecordClientInfo& aidl); 75 ConversionResult<media::RecordClientInfo> 76 legacy2aidl_record_client_info_t_RecordClientInfo(const record_client_info_t& legacy); 77 78 typedef void (*audio_error_callback)(status_t err); 79 typedef void (*dynamic_policy_callback)(int event, String8 regId, int val); 80 typedef void (*record_config_callback)(int event, 81 const record_client_info_t *clientInfo, 82 const audio_config_base_t *clientConfig, 83 std::vector<effect_descriptor_t> clientEffects, 84 const audio_config_base_t *deviceConfig, 85 std::vector<effect_descriptor_t> effects, 86 audio_patch_handle_t patchHandle, 87 audio_source_t source); 88 typedef void (*routing_callback)(); 89 typedef void (*vol_range_init_req_callback)(); 90 91 class CaptureStateListenerImpl; 92 class IAudioFlinger; 93 class String8; 94 95 namespace media { 96 class IAudioPolicyService; 97 } 98 99 class AudioSystem 100 { 101 friend class AudioFlingerClient; 102 friend class AudioPolicyServiceClient; 103 friend class CaptureStateListenerImpl; 104 template <typename ServiceInterface, typename Client, typename AidlInterface, 105 typename ServiceTraits> 106 friend class ServiceHandler; 107 friend class AudioFlingerServiceTraits; 108 109 public: 110 111 // FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp 112 113 /* These are static methods to control the system-wide AudioFlinger 114 * only privileged processes can have access to them 115 */ 116 117 // mute/unmute microphone 118 static status_t muteMicrophone(bool state); 119 static status_t isMicrophoneMuted(bool *state); 120 121 // set/get master volume 122 static status_t setMasterVolume(float value); 123 static status_t getMasterVolume(float* volume); 124 125 // mute/unmute audio outputs 126 static status_t setMasterMute(bool mute); 127 static status_t getMasterMute(bool* mute); 128 129 // set stream volume on specified output 130 static status_t setStreamVolume(audio_stream_type_t stream, float value, 131 bool muted, audio_io_handle_t output); 132 133 // mute/unmute stream 134 static status_t setStreamMute(audio_stream_type_t stream, bool mute); 135 136 /** 137 * Set volume for given AudioTrack port ids on specified output 138 * @param portIds to consider 139 * @param volume to set 140 * @param muted to set 141 * @param output to consider 142 * @return NO_ERROR if successful 143 */ 144 static status_t setPortsVolume(const std::vector<audio_port_handle_t>& portIds, 145 float volume, bool muted, audio_io_handle_t output); 146 147 // set audio mode in audio hardware 148 static status_t setMode(audio_mode_t mode); 149 150 // test API: switch HALs into the mode which simulates external device connections 151 static status_t setSimulateDeviceConnections(bool enabled); 152 153 // returns true in *state if tracks are active on the specified stream or have been active 154 // in the past inPastMs milliseconds 155 static status_t isStreamActive(audio_stream_type_t stream, bool *state, uint32_t inPastMs); 156 // returns true in *state if tracks are active for what qualifies as remote playback 157 // on the specified stream or have been active in the past inPastMs milliseconds. Remote 158 // playback isn't mutually exclusive with local playback. 159 static status_t isStreamActiveRemotely(audio_stream_type_t stream, bool *state, 160 uint32_t inPastMs); 161 // returns true in *state if a recorder is currently recording with the specified source 162 static status_t isSourceActive(audio_source_t source, bool *state); 163 164 // set/get audio hardware parameters. The function accepts a list of parameters 165 // key value pairs in the form: key1=value1;key2=value2;... 166 // Some keys are reserved for standard parameters (See AudioParameter class). 167 // The versions with audio_io_handle_t are intended for internal media framework use only. 168 static status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); 169 static String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 170 // The versions without audio_io_handle_t are intended for JNI. 171 static status_t setParameters(const String8& keyValuePairs); 172 static String8 getParameters(const String8& keys); 173 174 // Registers an error callback. When this callback is invoked, it means all 175 // state implied by this interface has been reset. 176 // Returns a token that can be used for un-registering. 177 // Might block while callbacks are being invoked. 178 static uintptr_t addErrorCallback(audio_error_callback cb); 179 180 // Un-registers a callback previously added with addErrorCallback. 181 // Might block while callbacks are being invoked. 182 static void removeErrorCallback(uintptr_t cb); 183 184 static void setDynPolicyCallback(dynamic_policy_callback cb); 185 static void setRecordConfigCallback(record_config_callback); 186 static void setRoutingCallback(routing_callback cb); 187 static void setVolInitReqCallback(vol_range_init_req_callback cb); 188 189 // Sets the binder to use for accessing the AudioFlinger service. This enables the system server 190 // to grant specific isolated processes access to the audio system. Currently used only for the 191 // HotwordDetectionService. 192 static void setAudioFlingerBinder(const sp<IBinder>& audioFlinger); 193 194 // Sets a local AudioFlinger interface to be used by AudioSystem. 195 // This is used by audioserver main() to avoid binder AIDL translation. 196 static status_t setLocalAudioFlinger(const sp<IAudioFlinger>& af); 197 198 // helper function to obtain AudioFlinger service handle 199 static sp<IAudioFlinger> get_audio_flinger(); 200 201 // function to disable creation of thread pool (Used for testing). 202 // This should be called before get_audio_flinger() or get_audio_policy_service(). 203 static void disableThreadPool(); 204 205 static float linearToLog(int volume); 206 static int logToLinear(float volume); 207 static size_t calculateMinFrameCount( 208 uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate, 209 uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/); 210 211 // Returned samplingRate and frameCount output values are guaranteed 212 // to be non-zero if status == NO_ERROR 213 // FIXME This API assumes a route, and so should be deprecated. 214 static status_t getOutputSamplingRate(uint32_t* samplingRate, 215 audio_stream_type_t stream); 216 // FIXME This API assumes a route, and so should be deprecated. 217 static status_t getOutputFrameCount(size_t* frameCount, 218 audio_stream_type_t stream); 219 // FIXME This API assumes a route, and so should be deprecated. 220 static status_t getOutputLatency(uint32_t* latency, 221 audio_stream_type_t stream); 222 // returns the audio HAL sample rate 223 static status_t getSamplingRate(audio_io_handle_t ioHandle, 224 uint32_t* samplingRate); 225 // For output threads with a fast mixer, returns the number of frames per normal mixer buffer. 226 // For output threads without a fast mixer, or for input, this is same as getFrameCountHAL(). 227 static status_t getFrameCount(audio_io_handle_t ioHandle, 228 size_t* frameCount); 229 // returns the audio output latency in ms. Corresponds to 230 // audio_stream_out->get_latency() 231 static status_t getLatency(audio_io_handle_t output, 232 uint32_t* latency); 233 234 // return status NO_ERROR implies *buffSize > 0 235 // FIXME This API assumes a route, and so should deprecated. 236 static status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 237 audio_channel_mask_t channelMask, size_t* buffSize); 238 239 static status_t setVoiceVolume(float volume); 240 241 // return the number of audio frames written by AudioFlinger to audio HAL and 242 // audio dsp to DAC since the specified output has exited standby. 243 // returned status (from utils/Errors.h) can be: 244 // - NO_ERROR: successful operation, halFrames and dspFrames point to valid data 245 // - INVALID_OPERATION: Not supported on current hardware platform 246 // - BAD_VALUE: invalid parameter 247 // NOTE: this feature is not supported on all hardware platforms and it is 248 // necessary to check returned status before using the returned values. 249 static status_t getRenderPosition(audio_io_handle_t output, 250 uint32_t *halFrames, 251 uint32_t *dspFrames); 252 253 // return the number of input frames lost by HAL implementation, or 0 if the handle is invalid 254 static uint32_t getInputFramesLost(audio_io_handle_t ioHandle); 255 256 // Allocate a new unique ID for use as an audio session ID or I/O handle. 257 // If unable to contact AudioFlinger, returns AUDIO_UNIQUE_ID_ALLOCATE instead. 258 // FIXME If AudioFlinger were to ever exhaust the unique ID namespace, 259 // this method could fail by returning either a reserved ID like AUDIO_UNIQUE_ID_ALLOCATE 260 // or an unspecified existing unique ID. 261 static audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 262 263 static void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid); 264 static void releaseAudioSessionId(audio_session_t audioSession, pid_t pid); 265 266 // Get the HW synchronization source used for an audio session. 267 // Return a valid source or AUDIO_HW_SYNC_INVALID if an error occurs 268 // or no HW sync source is used. 269 static audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId); 270 271 // Indicate JAVA services are ready (scheduling, power management ...) 272 static status_t systemReady(); 273 274 // Indicate audio policy service is ready 275 static status_t audioPolicyReady(); 276 277 // Returns the number of frames per audio HAL buffer. 278 // Corresponds to audio_stream->get_buffer_size()/audio_stream_in_frame_size() for input. 279 // See also getFrameCount(). 280 static status_t getFrameCountHAL(audio_io_handle_t ioHandle, 281 size_t* frameCount); 282 283 // Events used to synchronize actions between audio sessions. 284 // For instance SYNC_EVENT_PRESENTATION_COMPLETE can be used to delay recording start until 285 // playback is complete on another audio session. 286 // See definitions in MediaSyncEvent.java 287 enum sync_event_t { 288 SYNC_EVENT_SAME = -1, // used internally to indicate restart with same event 289 SYNC_EVENT_NONE = 0, 290 SYNC_EVENT_PRESENTATION_COMPLETE, 291 292 // 293 // Define new events here: SYNC_EVENT_START, SYNC_EVENT_STOP, SYNC_EVENT_TIME ... 294 // 295 SYNC_EVENT_CNT, 296 }; 297 298 // Timeout for synchronous record start. Prevents from blocking the record thread forever 299 // if the trigger event is not fired. 300 static const uint32_t kSyncRecordStartTimeOutMs = 30000; 301 302 // 303 // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions) 304 // 305 static void onNewAudioModulesAvailable(); 306 static status_t setDeviceConnectionState(audio_policy_dev_state_t state, 307 const android::media::audio::common::AudioPort& port, 308 audio_format_t encodedFormat, 309 bool deviceSwitch); 310 static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, 311 const char *device_address); 312 static status_t handleDeviceConfigChange(audio_devices_t device, 313 const char *device_address, 314 const char *device_name, 315 audio_format_t encodedFormat); 316 static status_t setPhoneState(audio_mode_t state, uid_t uid); 317 static status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 318 static audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 319 320 /** 321 * Get output stream for given parameters. 322 * 323 * @param[in] attr the requested audio attributes 324 * @param[in|out] output the io handle of the output for the playback. It is specified when 325 * starting mmap thread. 326 * @param[in] session the session id for the client 327 * @param[in|out] stream the stream type used for the playback 328 * @param[in] attributionSource a source to which access to permission protected data 329 * @param[in|out] config the requested configuration client, the suggested configuration will 330 * be returned if no proper output is found for requested configuration 331 * @param[in] flags the requested output flag from client 332 * @param[in|out] selectedDeviceId the requested device id for playback, the actual device id 333 * for playback will be returned 334 * @param[out] portId the generated port id to identify the client 335 * @param[out] secondaryOutputs collection of io handle for secondary outputs 336 * @param[out] isSpatialized true if the playback will be spatialized 337 * @param[out] isBitPerfect true if the playback will be bit-perfect 338 * @return if the call is successful or not 339 */ 340 static status_t getOutputForAttr(audio_attributes_t *attr, 341 audio_io_handle_t *output, 342 audio_session_t session, 343 audio_stream_type_t *stream, 344 const AttributionSourceState& attributionSource, 345 audio_config_t *config, 346 audio_output_flags_t flags, 347 DeviceIdVector *selectedDeviceIds, 348 audio_port_handle_t *portId, 349 std::vector<audio_io_handle_t> *secondaryOutputs, 350 bool *isSpatialized, 351 bool *isBitPerfect, 352 float *volume, 353 bool *muted); 354 static status_t startOutput(audio_port_handle_t portId); 355 static status_t stopOutput(audio_port_handle_t portId); 356 static void releaseOutput(audio_port_handle_t portId); 357 358 /** 359 * Get input stream for given parameters. 360 * Client must successfully hand off the handle reference to AudioFlinger via createRecord(), 361 * or release it with releaseInput(). 362 * 363 * @param[in] attr the requested audio attributes 364 * @param[in|out] input the io handle of the input for the capture. It is specified when 365 * starting mmap thread. 366 * @param[in] riid an unique id to identify the record client 367 * @param[in] session the session id for the client 368 * @param[in] attributionSource a source to which access to permission protected data 369 * @param[in|out] config the requested configuration client, the suggested configuration will 370 * be returned if no proper input is found for requested configuration 371 * @param[in] flags the requested input flag from client 372 * @param[in|out] selectedDeviceId the requested device id for playback, the actual device id 373 * for playback will be returned 374 * @param[out] portId the generated port id to identify the client 375 * @param[out] source the audio source validated by audio policy manager 376 * @return if the call is successful or not 377 */ 378 static status_t getInputForAttr(const audio_attributes_t *attr, 379 audio_io_handle_t *input, 380 audio_unique_id_t riid, 381 audio_session_t session, 382 const AttributionSourceState& attributionSource, 383 audio_config_base_t *config, 384 audio_input_flags_t flags, 385 audio_port_handle_t *selectedDeviceId, 386 audio_port_handle_t *portId, 387 audio_source_t *source); 388 389 static status_t startInput(audio_port_handle_t portId); 390 static status_t stopInput(audio_port_handle_t portId); 391 static void releaseInput(audio_port_handle_t portId); 392 static status_t setDeviceAbsoluteVolumeEnabled(audio_devices_t deviceType, 393 const char *address, 394 bool enabled, 395 audio_stream_type_t streamToDriveAbs); 396 static status_t initStreamVolume(audio_stream_type_t stream, 397 int indexMin, 398 int indexMax); 399 static status_t setStreamVolumeIndex(audio_stream_type_t stream, 400 int index, 401 bool muted, 402 audio_devices_t device); 403 static status_t getStreamVolumeIndex(audio_stream_type_t stream, 404 int *index, 405 audio_devices_t device); 406 407 static status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, 408 int index, 409 bool muted, 410 audio_devices_t device); 411 static status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, 412 int &index, 413 audio_devices_t device); 414 415 static status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); 416 417 static status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); 418 419 static product_strategy_t getStrategyForStream(audio_stream_type_t stream); 420 static status_t getDevicesForAttributes(const audio_attributes_t &aa, 421 AudioDeviceTypeAddrVector *devices, 422 bool forVolume); 423 424 static audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc); 425 static status_t registerEffect(const effect_descriptor_t *desc, 426 audio_io_handle_t io, 427 product_strategy_t strategy, 428 audio_session_t session, 429 int id); 430 static status_t unregisterEffect(int id); 431 static status_t setEffectEnabled(int id, bool enabled); 432 static status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io); 433 434 // Sets a local AudioPolicyService interface to be used by AudioSystem. 435 // This is used by audioserver main() to allow client object initialization 436 // before exposing any interfaces to ServiceManager. 437 static status_t setLocalAudioPolicyService(const sp<media::IAudioPolicyService>& aps); 438 439 static sp<media::IAudioPolicyService> get_audio_policy_service(); 440 441 // helpers for android.media.AudioManager.getProperty(), see description there for meaning 442 static uint32_t getPrimaryOutputSamplingRate(); 443 static size_t getPrimaryOutputFrameCount(); 444 445 static status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory); 446 447 static status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages); 448 449 static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy); 450 451 // Indicate if hw offload is possible for given format, stream type, sample rate, 452 // bit rate, duration, video and streaming or offload property is enabled and when possible 453 // if gapless transitions are supported. 454 static audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info); 455 456 // check presence of audio flinger service. 457 // returns NO_ERROR if binding to service succeeds, DEAD_OBJECT otherwise 458 static status_t checkAudioFlinger(); 459 460 /* List available audio ports and their attributes */ 461 static status_t listAudioPorts(audio_port_role_t role, 462 audio_port_type_t type, 463 unsigned int *num_ports, 464 struct audio_port_v7 *ports, 465 unsigned int *generation); 466 467 static status_t listDeclaredDevicePorts(media::AudioPortRole role, 468 std::vector<media::AudioPortFw>* result); 469 470 /* Get attributes for a given audio port. On input, the port 471 * only needs the 'id' field to be filled in. */ 472 static status_t getAudioPort(struct audio_port_v7 *port); 473 474 /* Create an audio patch between several source and sink ports */ 475 static status_t createAudioPatch(const struct audio_patch *patch, 476 audio_patch_handle_t *handle); 477 478 /* Release an audio patch */ 479 static status_t releaseAudioPatch(audio_patch_handle_t handle); 480 481 /* List existing audio patches */ 482 static status_t listAudioPatches(unsigned int *num_patches, 483 struct audio_patch *patches, 484 unsigned int *generation); 485 /* Set audio port configuration */ 486 static status_t setAudioPortConfig(const struct audio_port_config *config); 487 488 489 static status_t acquireSoundTriggerSession(audio_session_t *session, 490 audio_io_handle_t *ioHandle, 491 audio_devices_t *device); 492 static status_t releaseSoundTriggerSession(audio_session_t session); 493 494 static audio_mode_t getPhoneState(); 495 496 static status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration); 497 498 static status_t getRegisteredPolicyMixes(std::vector<AudioMix>& mixes); 499 500 static status_t updatePolicyMixes( 501 const std::vector< 502 std::pair<AudioMix, std::vector<AudioMixMatchCriterion>>>& mixesWithUpdates); 503 504 static status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices); 505 506 static status_t removeUidDeviceAffinities(uid_t uid); 507 508 static status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices); 509 510 static status_t removeUserIdDeviceAffinities(int userId); 511 512 static status_t startAudioSource(const struct audio_port_config *source, 513 const audio_attributes_t *attributes, 514 audio_port_handle_t *portId); 515 static status_t stopAudioSource(audio_port_handle_t portId); 516 517 static status_t setMasterMono(bool mono); 518 static status_t getMasterMono(bool *mono); 519 520 static status_t setMasterBalance(float balance); 521 static status_t getMasterBalance(float *balance); 522 523 static float getStreamVolumeDB( 524 audio_stream_type_t stream, int index, audio_devices_t device); 525 526 static status_t getMicrophones(std::vector<media::MicrophoneInfoFw> *microphones); 527 528 static status_t getHwOffloadFormatsSupportedForBluetoothMedia( 529 audio_devices_t device, std::vector<audio_format_t> *formats); 530 531 // numSurroundFormats holds the maximum number of formats and bool value allowed in the array. 532 // When numSurroundFormats is 0, surroundFormats and surroundFormatsEnabled will not be 533 // populated. The actual number of surround formats should be returned at numSurroundFormats. 534 static status_t getSurroundFormats(unsigned int *numSurroundFormats, 535 audio_format_t *surroundFormats, 536 bool *surroundFormatsEnabled); 537 static status_t getReportedSurroundFormats(unsigned int *numSurroundFormats, 538 audio_format_t *surroundFormats); 539 static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled); 540 541 static status_t setAssistantServicesUids(const std::vector<uid_t>& uids); 542 static status_t setActiveAssistantServicesUids(const std::vector<uid_t>& activeUids); 543 544 static status_t setA11yServicesUids(const std::vector<uid_t>& uids); 545 static status_t setCurrentImeUid(uid_t uid); 546 547 static bool isHapticPlaybackSupported(); 548 549 static bool isUltrasoundSupported(); 550 551 static status_t listAudioProductStrategies(AudioProductStrategyVector &strategies); 552 static status_t getProductStrategyFromAudioAttributes( 553 const audio_attributes_t &aa, product_strategy_t &productStrategy, 554 bool fallbackOnDefault = true); 555 556 static audio_attributes_t streamTypeToAttributes(audio_stream_type_t stream); 557 static audio_stream_type_t attributesToStreamType(const audio_attributes_t &attr); 558 559 static status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups); 560 561 static status_t getVolumeGroupFromAudioAttributes( 562 const audio_attributes_t &aa, volume_group_t &volumeGroup, 563 bool fallbackOnDefault = true); 564 565 static status_t setRttEnabled(bool enabled); 566 567 static bool isCallScreenModeSupported(); 568 569 /** 570 * Send audio HAL server process pids to native audioserver process for use 571 * when generating audio HAL servers tombstones 572 */ 573 static status_t setAudioHalPids(const std::vector<pid_t>& pids); 574 575 static status_t setDevicesRoleForStrategy(product_strategy_t strategy, 576 device_role_t role, const AudioDeviceTypeAddrVector &devices); 577 578 static status_t removeDevicesRoleForStrategy(product_strategy_t strategy, 579 device_role_t role, const AudioDeviceTypeAddrVector &devices); 580 581 static status_t clearDevicesRoleForStrategy(product_strategy_t strategy, 582 device_role_t role); 583 584 static status_t getDevicesForRoleAndStrategy(product_strategy_t strategy, 585 device_role_t role, AudioDeviceTypeAddrVector &devices); 586 587 static status_t setDevicesRoleForCapturePreset(audio_source_t audioSource, 588 device_role_t role, const AudioDeviceTypeAddrVector &devices); 589 590 static status_t addDevicesRoleForCapturePreset(audio_source_t audioSource, 591 device_role_t role, const AudioDeviceTypeAddrVector &devices); 592 593 static status_t removeDevicesRoleForCapturePreset( 594 audio_source_t audioSource, device_role_t role, 595 const AudioDeviceTypeAddrVector& devices); 596 597 static status_t clearDevicesRoleForCapturePreset( 598 audio_source_t audioSource, device_role_t role); 599 600 static status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource, 601 device_role_t role, AudioDeviceTypeAddrVector &devices); 602 603 static status_t getDeviceForStrategy(product_strategy_t strategy, 604 AudioDeviceTypeAddr &device); 605 606 607 /** 608 * If a spatializer stage effect is present on the platform, this will return an 609 * ISpatializer interface to control this feature. 610 * If no spatializer stage is present, a null interface is returned. 611 * The INativeSpatializerCallback passed must not be null. 612 * Only one ISpatializer interface can exist at a given time. The native audio policy 613 * service will reject the request if an interface was already acquired and previous owner 614 * did not die or call ISpatializer.release(). 615 * @param callback in: the callback to receive state updates if the ISpatializer 616 * interface is acquired. 617 * @param spatializer out: the ISpatializer interface made available to control the 618 * platform spatializer 619 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, PERMISSION_DENIED, BAD_VALUE 620 * in case of error. 621 */ 622 static status_t getSpatializer(const sp<media::INativeSpatializerCallback>& callback, 623 sp<media::ISpatializer>* spatializer); 624 625 /** 626 * Queries if some kind of spatialization will be performed if the audio playback context 627 * described by the provided arguments is present. 628 * The context is made of: 629 * - The audio attributes describing the playback use case. 630 * - The audio configuration describing the audio format, channels, sampling rate ... 631 * - The devices describing the sink audio device selected for playback. 632 * All arguments are optional and only the specified arguments are used to match against 633 * supported criteria. For instance, supplying no argument will tell if spatialization is 634 * supported or not in general. 635 * @param attr audio attributes describing the playback use case 636 * @param config audio configuration describing the audio format, channels, sampling rate... 637 * @param devices the sink audio device selected for playback 638 * @param canBeSpatialized out: true if spatialization is enabled for this context, 639 * false otherwise 640 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE 641 * in case of error. 642 */ 643 static status_t canBeSpatialized(const audio_attributes_t *attr, 644 const audio_config_t *config, 645 const AudioDeviceTypeAddrVector &devices, 646 bool *canBeSpatialized); 647 648 /** 649 * Registers the sound dose callback with the audio server and returns the ISoundDose 650 * interface. 651 * 652 * \param callback to send messages to the audio server 653 * \param soundDose binder to send messages to the AudioService 654 **/ 655 static status_t getSoundDoseInterface(const sp<media::ISoundDoseCallback>& callback, 656 sp<media::ISoundDose>* soundDose); 657 658 /** 659 * Query how the direct playback is currently supported on the device. 660 * @param attr audio attributes describing the playback use case 661 * @param config audio configuration for the playback 662 * @param directMode out: a set of flags describing how the direct playback is currently 663 * supported on the device 664 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE, PERMISSION_DENIED 665 * in case of error. 666 */ 667 static status_t getDirectPlaybackSupport(const audio_attributes_t *attr, 668 const audio_config_t *config, 669 audio_direct_mode_t *directMode); 670 671 672 /** 673 * Query which direct audio profiles are available for the specified audio attributes. 674 * @param attr audio attributes describing the playback use case 675 * @param audioProfiles out: a vector of audio profiles 676 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE, PERMISSION_DENIED 677 * in case of error. 678 */ 679 static status_t getDirectProfilesForAttributes(const audio_attributes_t* attr, 680 std::vector<audio_profile>* audioProfiles); 681 682 static status_t setRequestedLatencyMode( 683 audio_io_handle_t output, audio_latency_mode_t mode); 684 685 static status_t getSupportedLatencyModes(audio_io_handle_t output, 686 std::vector<audio_latency_mode_t>* modes); 687 688 static status_t setBluetoothVariableLatencyEnabled(bool enabled); 689 690 static status_t isBluetoothVariableLatencyEnabled(bool *enabled); 691 692 static status_t supportsBluetoothVariableLatency(bool *support); 693 694 static status_t getSupportedMixerAttributes(audio_port_handle_t portId, 695 std::vector<audio_mixer_attributes_t> *mixerAttrs); 696 static status_t setPreferredMixerAttributes(const audio_attributes_t *attr, 697 audio_port_handle_t portId, 698 uid_t uid, 699 const audio_mixer_attributes_t *mixerAttr); 700 static status_t getPreferredMixerAttributes(const audio_attributes_t* attr, 701 audio_port_handle_t portId, 702 std::optional<audio_mixer_attributes_t>* mixerAttr); 703 static status_t clearPreferredMixerAttributes(const audio_attributes_t* attr, 704 audio_port_handle_t portId, 705 uid_t uid); 706 707 static status_t getAudioPolicyConfig(media::AudioPolicyConfig *config); 708 709 // A listener for capture state changes. 710 class CaptureStateListener : public virtual RefBase { 711 public: 712 // Called whenever capture state changes. 713 virtual void onStateChanged(bool active) = 0; 714 // Called whenever the service dies (and hence our listener is no longer 715 // registered). 716 virtual void onServiceDied() = 0; 717 718 virtual ~CaptureStateListener() = default; 719 }; 720 721 // Registers a listener for sound trigger capture state changes. 722 // There may only be one such listener registered at any point. 723 // The listener onStateChanged() method will be invoked synchronously from 724 // this call with the initial value. 725 // The listener onServiceDied() method will be invoked synchronously from 726 // this call if initial attempt to register failed. 727 // If the audio policy service cannot be reached, this method will return 728 // PERMISSION_DENIED and will not invoke the callback, otherwise, it will 729 // return NO_ERROR. 730 static status_t registerSoundTriggerCaptureStateListener( 731 const sp<CaptureStateListener>& listener); 732 733 // ---------------------------------------------------------------------------- 734 735 class AudioVolumeGroupCallback : public virtual RefBase 736 { 737 public: 738 AudioVolumeGroupCallback()739 AudioVolumeGroupCallback() {} ~AudioVolumeGroupCallback()740 virtual ~AudioVolumeGroupCallback() {} 741 742 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0; 743 }; 744 745 static status_t addAudioVolumeGroupCallback( 746 const sp<media::INativeAudioVolumeGroupCallback>& callback); 747 static status_t removeAudioVolumeGroupCallback( 748 const sp<media::INativeAudioVolumeGroupCallback>& callback); 749 750 class AudioPortCallback : public virtual RefBase 751 { 752 public: 753 AudioPortCallback()754 AudioPortCallback() {} ~AudioPortCallback()755 virtual ~AudioPortCallback() {} 756 757 virtual void onAudioPortListUpdate() = 0; 758 virtual void onAudioPatchListUpdate() = 0; 759 virtual void onServiceDied() = 0; 760 761 }; 762 763 static status_t addAudioPortCallback(const sp<AudioPortCallback>& callback); 764 static status_t removeAudioPortCallback(const sp<AudioPortCallback>& callback); 765 766 class AudioDeviceCallback : public virtual RefBase 767 { 768 public: 769 AudioDeviceCallback()770 AudioDeviceCallback() {} ~AudioDeviceCallback()771 virtual ~AudioDeviceCallback() {} 772 773 virtual void onAudioDeviceUpdate(audio_io_handle_t audioIo, 774 const DeviceIdVector& deviceIds) = 0; 775 }; 776 777 static status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 778 audio_io_handle_t audioIo, 779 audio_port_handle_t portId); 780 static status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 781 audio_io_handle_t audioIo, 782 audio_port_handle_t portId); 783 784 class SupportedLatencyModesCallback : public virtual RefBase 785 { 786 public: 787 788 SupportedLatencyModesCallback() = default; 789 virtual ~SupportedLatencyModesCallback() = default; 790 791 virtual void onSupportedLatencyModesChanged( 792 audio_io_handle_t output, const std::vector<audio_latency_mode_t>& modes) = 0; 793 }; 794 795 static status_t addSupportedLatencyModesCallback( 796 const sp<SupportedLatencyModesCallback>& callback); 797 static status_t removeSupportedLatencyModesCallback( 798 const sp<SupportedLatencyModesCallback>& callback); 799 800 static status_t getDeviceIdsForIo(audio_io_handle_t audioIo, DeviceIdVector& deviceIds); 801 802 static status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos); 803 804 static status_t getMmapPolicyInfos( 805 media::audio::common::AudioMMapPolicyType policyType, 806 std::vector<media::audio::common::AudioMMapPolicyInfo> *policyInfos); 807 808 static int32_t getAAudioMixerBurstCount(); 809 810 static int32_t getAAudioHardwareBurstMinUsec(); 811 812 static status_t getMmapPolicyForDevice( 813 media::audio::common::AudioMMapPolicyType policyType, audio_devices_t device, 814 media::audio::common::AudioMMapPolicyInfo *policyInfo); 815 816 class AudioFlingerClient: public media::BnAudioFlingerClient 817 { 818 public: 819 AudioFlingerClient() = default; 820 821 void clearIoCache() EXCLUDES(mMutex); 822 status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 823 audio_channel_mask_t channelMask, size_t* buffSize) EXCLUDES(mMutex); 824 sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle) EXCLUDES(mMutex); 825 826 // IAudioFlingerClient 827 828 // indicate a change in the configuration of an output or input: keeps the cached 829 // values for output/input parameters up-to-date in client process 830 binder::Status ioConfigChanged( 831 media::AudioIoConfigEvent event, 832 const media::AudioIoDescriptor& ioDesc) final EXCLUDES(mMutex); 833 834 binder::Status onSupportedLatencyModesChanged( 835 int output, 836 const std::vector<media::audio::common::AudioLatencyMode>& latencyModes) 837 final EXCLUDES(mMutex); 838 839 status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 840 audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex); 841 status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 842 audio_io_handle_t audioIo, audio_port_handle_t portId) EXCLUDES(mMutex); 843 844 status_t addSupportedLatencyModesCallback( 845 const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex); 846 status_t removeSupportedLatencyModesCallback( 847 const sp<SupportedLatencyModesCallback>& callback) EXCLUDES(mMutex); 848 849 status_t getDeviceIdsForIo(audio_io_handle_t audioIo, DeviceIdVector& deviceIds) 850 EXCLUDES(mMutex); 851 852 private: 853 mutable std::mutex mMutex; 854 std::map<audio_io_handle_t, sp<AudioIoDescriptor>> mIoDescriptors GUARDED_BY(mMutex); 855 856 std::map<audio_io_handle_t, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>> 857 mAudioDeviceCallbacks GUARDED_BY(mMutex); 858 859 std::vector<wp<SupportedLatencyModesCallback>> 860 mSupportedLatencyModesCallbacks GUARDED_BY(mMutex); 861 862 // cached values for recording getInputBufferSize() queries 863 size_t mInBuffSize GUARDED_BY(mMutex) = 0; // zero indicates cache is invalid 864 uint32_t mInSamplingRate GUARDED_BY(mMutex) = 0; 865 audio_format_t mInFormat GUARDED_BY(mMutex) = AUDIO_FORMAT_DEFAULT; 866 audio_channel_mask_t mInChannelMask GUARDED_BY(mMutex) = AUDIO_CHANNEL_NONE; 867 868 sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle) REQUIRES(mMutex); 869 }; 870 871 class AudioPolicyServiceClient: public media::BnAudioPolicyServiceClient { 872 public: 873 AudioPolicyServiceClient() = default; 874 875 int addAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex); 876 877 int removeAudioPortCallback(const sp<AudioPortCallback>& callback) EXCLUDES(mMutex); 878 isAudioPortCbEnabled()879 bool isAudioPortCbEnabled() const EXCLUDES(mMutex) { 880 std::lock_guard _l(mMutex); 881 return !mAudioPortCallbacks.empty(); 882 } 883 884 int addAudioVolumeGroupCallback( 885 const sp<media::INativeAudioVolumeGroupCallback>& callback) EXCLUDES(mMutex); 886 887 int removeAudioVolumeGroupCallback( 888 const sp<media::INativeAudioVolumeGroupCallback>& callback) EXCLUDES(mMutex); 889 isAudioVolumeGroupCbEnabled()890 bool isAudioVolumeGroupCbEnabled() const EXCLUDES(mMutex) { 891 std::lock_guard _l(mMutex); 892 return !mAudioVolumeGroupCallbacks.empty(); 893 } 894 895 void onServiceDied(); 896 897 // IAudioPolicyServiceClient 898 binder::Status onAudioVolumeGroupChanged(int32_t group, int32_t flags) override; 899 binder::Status onAudioPortListUpdate() override; 900 binder::Status onAudioPatchListUpdate() override; 901 binder::Status onDynamicPolicyMixStateUpdate(const std::string& regId, 902 int32_t state) override; 903 binder::Status onRecordingConfigurationUpdate( 904 int32_t event, 905 const media::RecordClientInfo& clientInfo, 906 const media::audio::common::AudioConfigBase& clientConfig, 907 const std::vector<media::EffectDescriptor>& clientEffects, 908 const media::audio::common::AudioConfigBase& deviceConfig, 909 const std::vector<media::EffectDescriptor>& effects, 910 int32_t patchHandle, 911 media::audio::common::AudioSource source) override; 912 binder::Status onRoutingUpdated(); 913 binder::Status onVolumeRangeInitRequest(); 914 915 private: 916 mutable std::mutex mMutex; 917 std::set<sp<AudioPortCallback>> mAudioPortCallbacks GUARDED_BY(mMutex); 918 std::set<sp<media::INativeAudioVolumeGroupCallback>> mAudioVolumeGroupCallbacks 919 GUARDED_BY(mMutex); 920 }; 921 922 private: 923 924 static audio_io_handle_t getOutput(audio_stream_type_t stream); 925 static sp<AudioFlingerClient> getAudioFlingerClient(); 926 static sp<AudioPolicyServiceClient> getAudioPolicyClient(); 927 static sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle); 928 929 // Invokes all registered error callbacks with the given error code. 930 static void reportError(status_t err); 931 932 [[clang::no_destroy]] static std::mutex gMutex; 933 static dynamic_policy_callback gDynPolicyCallback GUARDED_BY(gMutex); 934 static record_config_callback gRecordConfigCallback GUARDED_BY(gMutex); 935 static routing_callback gRoutingCallback GUARDED_BY(gMutex); 936 static vol_range_init_req_callback gVolRangeInitReqCallback GUARDED_BY(gMutex); 937 938 [[clang::no_destroy]] static std::mutex gApsCallbackMutex; 939 [[clang::no_destroy]] static std::mutex gErrorCallbacksMutex; 940 [[clang::no_destroy]] static std::set<audio_error_callback> gAudioErrorCallbacks 941 GUARDED_BY(gErrorCallbacksMutex); 942 943 [[clang::no_destroy]] static std::mutex gSoundTriggerMutex; 944 [[clang::no_destroy]] static sp<CaptureStateListenerImpl> gSoundTriggerCaptureStateListener 945 GUARDED_BY(gSoundTriggerMutex); 946 }; 947 948 } // namespace android 949 950 #endif /*ANDROID_AUDIOSYSTEM_H_*/ 951