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