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 <android/media/AudioVibratorInfo.h> 23 #include <android/media/BnAudioFlingerClient.h> 24 #include <android/media/BnAudioPolicyServiceClient.h> 25 #include <android/media/INativeSpatializerCallback.h> 26 #include <android/media/ISpatializer.h> 27 #include <android/content/AttributionSourceState.h> 28 #include <media/AidlConversionUtil.h> 29 #include <media/AudioDeviceTypeAddr.h> 30 #include <media/AudioPolicy.h> 31 #include <media/AudioProductStrategy.h> 32 #include <media/AudioVolumeGroup.h> 33 #include <media/AudioIoDescriptor.h> 34 #include <media/MicrophoneInfo.h> 35 #include <set> 36 #include <system/audio.h> 37 #include <system/audio_effect.h> 38 #include <system/audio_policy.h> 39 #include <utils/Errors.h> 40 #include <utils/Mutex.h> 41 #include <vector> 42 43 using android::content::AttributionSourceState; 44 45 namespace android { 46 47 struct record_client_info { 48 audio_unique_id_t riid; 49 uid_t uid; 50 audio_session_t session; 51 audio_source_t source; 52 audio_port_handle_t port_id; 53 bool silenced; 54 }; 55 56 typedef struct record_client_info record_client_info_t; 57 58 // AIDL conversion functions. 59 ConversionResult<record_client_info_t> 60 aidl2legacy_RecordClientInfo_record_client_info_t(const media::RecordClientInfo& aidl); 61 ConversionResult<media::RecordClientInfo> 62 legacy2aidl_record_client_info_t_RecordClientInfo(const record_client_info_t& legacy); 63 64 typedef void (*audio_error_callback)(status_t err); 65 typedef void (*dynamic_policy_callback)(int event, String8 regId, int val); 66 typedef void (*record_config_callback)(int event, 67 const record_client_info_t *clientInfo, 68 const audio_config_base_t *clientConfig, 69 std::vector<effect_descriptor_t> clientEffects, 70 const audio_config_base_t *deviceConfig, 71 std::vector<effect_descriptor_t> effects, 72 audio_patch_handle_t patchHandle, 73 audio_source_t source); 74 typedef void (*routing_callback)(); 75 76 class IAudioFlinger; 77 class String8; 78 79 namespace media { 80 class IAudioPolicyService; 81 } 82 83 class AudioSystem 84 { 85 public: 86 87 // FIXME Declare in binder opcode order, similarly to IAudioFlinger.h and IAudioFlinger.cpp 88 89 /* These are static methods to control the system-wide AudioFlinger 90 * only privileged processes can have access to them 91 */ 92 93 // mute/unmute microphone 94 static status_t muteMicrophone(bool state); 95 static status_t isMicrophoneMuted(bool *state); 96 97 // set/get master volume 98 static status_t setMasterVolume(float value); 99 static status_t getMasterVolume(float* volume); 100 101 // mute/unmute audio outputs 102 static status_t setMasterMute(bool mute); 103 static status_t getMasterMute(bool* mute); 104 105 // set/get stream volume on specified output 106 static status_t setStreamVolume(audio_stream_type_t stream, float value, 107 audio_io_handle_t output); 108 static status_t getStreamVolume(audio_stream_type_t stream, float* volume, 109 audio_io_handle_t output); 110 111 // mute/unmute stream 112 static status_t setStreamMute(audio_stream_type_t stream, bool mute); 113 static status_t getStreamMute(audio_stream_type_t stream, bool* mute); 114 115 // set audio mode in audio hardware 116 static status_t setMode(audio_mode_t mode); 117 118 // returns true in *state if tracks are active on the specified stream or have been active 119 // in the past inPastMs milliseconds 120 static status_t isStreamActive(audio_stream_type_t stream, bool *state, uint32_t inPastMs); 121 // returns true in *state if tracks are active for what qualifies as remote playback 122 // on the specified stream or have been active in the past inPastMs milliseconds. Remote 123 // playback isn't mutually exclusive with local playback. 124 static status_t isStreamActiveRemotely(audio_stream_type_t stream, bool *state, 125 uint32_t inPastMs); 126 // returns true in *state if a recorder is currently recording with the specified source 127 static status_t isSourceActive(audio_source_t source, bool *state); 128 129 // set/get audio hardware parameters. The function accepts a list of parameters 130 // key value pairs in the form: key1=value1;key2=value2;... 131 // Some keys are reserved for standard parameters (See AudioParameter class). 132 // The versions with audio_io_handle_t are intended for internal media framework use only. 133 static status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs); 134 static String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); 135 // The versions without audio_io_handle_t are intended for JNI. 136 static status_t setParameters(const String8& keyValuePairs); 137 static String8 getParameters(const String8& keys); 138 139 // Registers an error callback. When this callback is invoked, it means all 140 // state implied by this interface has been reset. 141 // Returns a token that can be used for un-registering. 142 // Might block while callbacks are being invoked. 143 static uintptr_t addErrorCallback(audio_error_callback cb); 144 145 // Un-registers a callback previously added with addErrorCallback. 146 // Might block while callbacks are being invoked. 147 static void removeErrorCallback(uintptr_t cb); 148 149 static void setDynPolicyCallback(dynamic_policy_callback cb); 150 static void setRecordConfigCallback(record_config_callback); 151 static void setRoutingCallback(routing_callback cb); 152 153 // Sets the binder to use for accessing the AudioFlinger service. This enables the system server 154 // to grant specific isolated processes access to the audio system. Currently used only for the 155 // HotwordDetectionService. 156 static void setAudioFlingerBinder(const sp<IBinder>& audioFlinger); 157 158 // helper function to obtain AudioFlinger service handle 159 static const sp<IAudioFlinger> get_audio_flinger(); 160 161 static float linearToLog(int volume); 162 static int logToLinear(float volume); 163 static size_t calculateMinFrameCount( 164 uint32_t afLatencyMs, uint32_t afFrameCount, uint32_t afSampleRate, 165 uint32_t sampleRate, float speed /*, uint32_t notificationsPerBufferReq*/); 166 167 // Returned samplingRate and frameCount output values are guaranteed 168 // to be non-zero if status == NO_ERROR 169 // FIXME This API assumes a route, and so should be deprecated. 170 static status_t getOutputSamplingRate(uint32_t* samplingRate, 171 audio_stream_type_t stream); 172 // FIXME This API assumes a route, and so should be deprecated. 173 static status_t getOutputFrameCount(size_t* frameCount, 174 audio_stream_type_t stream); 175 // FIXME This API assumes a route, and so should be deprecated. 176 static status_t getOutputLatency(uint32_t* latency, 177 audio_stream_type_t stream); 178 // returns the audio HAL sample rate 179 static status_t getSamplingRate(audio_io_handle_t ioHandle, 180 uint32_t* samplingRate); 181 // For output threads with a fast mixer, returns the number of frames per normal mixer buffer. 182 // For output threads without a fast mixer, or for input, this is same as getFrameCountHAL(). 183 static status_t getFrameCount(audio_io_handle_t ioHandle, 184 size_t* frameCount); 185 // returns the audio output latency in ms. Corresponds to 186 // audio_stream_out->get_latency() 187 static status_t getLatency(audio_io_handle_t output, 188 uint32_t* latency); 189 190 // return status NO_ERROR implies *buffSize > 0 191 // FIXME This API assumes a route, and so should deprecated. 192 static status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 193 audio_channel_mask_t channelMask, size_t* buffSize); 194 195 static status_t setVoiceVolume(float volume); 196 197 // return the number of audio frames written by AudioFlinger to audio HAL and 198 // audio dsp to DAC since the specified output has exited standby. 199 // returned status (from utils/Errors.h) can be: 200 // - NO_ERROR: successful operation, halFrames and dspFrames point to valid data 201 // - INVALID_OPERATION: Not supported on current hardware platform 202 // - BAD_VALUE: invalid parameter 203 // NOTE: this feature is not supported on all hardware platforms and it is 204 // necessary to check returned status before using the returned values. 205 static status_t getRenderPosition(audio_io_handle_t output, 206 uint32_t *halFrames, 207 uint32_t *dspFrames); 208 209 // return the number of input frames lost by HAL implementation, or 0 if the handle is invalid 210 static uint32_t getInputFramesLost(audio_io_handle_t ioHandle); 211 212 // Allocate a new unique ID for use as an audio session ID or I/O handle. 213 // If unable to contact AudioFlinger, returns AUDIO_UNIQUE_ID_ALLOCATE instead. 214 // FIXME If AudioFlinger were to ever exhaust the unique ID namespace, 215 // this method could fail by returning either a reserved ID like AUDIO_UNIQUE_ID_ALLOCATE 216 // or an unspecified existing unique ID. 217 static audio_unique_id_t newAudioUniqueId(audio_unique_id_use_t use); 218 219 static void acquireAudioSessionId(audio_session_t audioSession, pid_t pid, uid_t uid); 220 static void releaseAudioSessionId(audio_session_t audioSession, pid_t pid); 221 222 // Get the HW synchronization source used for an audio session. 223 // Return a valid source or AUDIO_HW_SYNC_INVALID if an error occurs 224 // or no HW sync source is used. 225 static audio_hw_sync_t getAudioHwSyncForSession(audio_session_t sessionId); 226 227 // Indicate JAVA services are ready (scheduling, power management ...) 228 static status_t systemReady(); 229 230 // Indicate audio policy service is ready 231 static status_t audioPolicyReady(); 232 233 // Returns the number of frames per audio HAL buffer. 234 // Corresponds to audio_stream->get_buffer_size()/audio_stream_in_frame_size() for input. 235 // See also getFrameCount(). 236 static status_t getFrameCountHAL(audio_io_handle_t ioHandle, 237 size_t* frameCount); 238 239 // Events used to synchronize actions between audio sessions. 240 // For instance SYNC_EVENT_PRESENTATION_COMPLETE can be used to delay recording start until 241 // playback is complete on another audio session. 242 // See definitions in MediaSyncEvent.java 243 enum sync_event_t { 244 SYNC_EVENT_SAME = -1, // used internally to indicate restart with same event 245 SYNC_EVENT_NONE = 0, 246 SYNC_EVENT_PRESENTATION_COMPLETE, 247 248 // 249 // Define new events here: SYNC_EVENT_START, SYNC_EVENT_STOP, SYNC_EVENT_TIME ... 250 // 251 SYNC_EVENT_CNT, 252 }; 253 254 // Timeout for synchronous record start. Prevents from blocking the record thread forever 255 // if the trigger event is not fired. 256 static const uint32_t kSyncRecordStartTimeOutMs = 30000; 257 258 // 259 // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions) 260 // 261 static void onNewAudioModulesAvailable(); 262 static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state, 263 const char *device_address, const char *device_name, 264 audio_format_t encodedFormat); 265 static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, 266 const char *device_address); 267 static status_t handleDeviceConfigChange(audio_devices_t device, 268 const char *device_address, 269 const char *device_name, 270 audio_format_t encodedFormat); 271 static status_t setPhoneState(audio_mode_t state, uid_t uid); 272 static status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); 273 static audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 274 275 static status_t getOutputForAttr(audio_attributes_t *attr, 276 audio_io_handle_t *output, 277 audio_session_t session, 278 audio_stream_type_t *stream, 279 const AttributionSourceState& attributionSource, 280 const audio_config_t *config, 281 audio_output_flags_t flags, 282 audio_port_handle_t *selectedDeviceId, 283 audio_port_handle_t *portId, 284 std::vector<audio_io_handle_t> *secondaryOutputs); 285 static status_t startOutput(audio_port_handle_t portId); 286 static status_t stopOutput(audio_port_handle_t portId); 287 static void releaseOutput(audio_port_handle_t portId); 288 289 // Client must successfully hand off the handle reference to AudioFlinger via createRecord(), 290 // or release it with releaseInput(). 291 static status_t getInputForAttr(const audio_attributes_t *attr, 292 audio_io_handle_t *input, 293 audio_unique_id_t riid, 294 audio_session_t session, 295 const AttributionSourceState& attributionSource, 296 const audio_config_base_t *config, 297 audio_input_flags_t flags, 298 audio_port_handle_t *selectedDeviceId, 299 audio_port_handle_t *portId); 300 301 static status_t startInput(audio_port_handle_t portId); 302 static status_t stopInput(audio_port_handle_t portId); 303 static void releaseInput(audio_port_handle_t portId); 304 static status_t initStreamVolume(audio_stream_type_t stream, 305 int indexMin, 306 int indexMax); 307 static status_t setStreamVolumeIndex(audio_stream_type_t stream, 308 int index, 309 audio_devices_t device); 310 static status_t getStreamVolumeIndex(audio_stream_type_t stream, 311 int *index, 312 audio_devices_t device); 313 314 static status_t setVolumeIndexForAttributes(const audio_attributes_t &attr, 315 int index, 316 audio_devices_t device); 317 static status_t getVolumeIndexForAttributes(const audio_attributes_t &attr, 318 int &index, 319 audio_devices_t device); 320 321 static status_t getMaxVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); 322 323 static status_t getMinVolumeIndexForAttributes(const audio_attributes_t &attr, int &index); 324 325 static product_strategy_t getStrategyForStream(audio_stream_type_t stream); 326 static audio_devices_t getDevicesForStream(audio_stream_type_t stream); 327 static status_t getDevicesForAttributes(const AudioAttributes &aa, 328 AudioDeviceTypeAddrVector *devices); 329 330 static audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc); 331 static status_t registerEffect(const effect_descriptor_t *desc, 332 audio_io_handle_t io, 333 product_strategy_t strategy, 334 audio_session_t session, 335 int id); 336 static status_t unregisterEffect(int id); 337 static status_t setEffectEnabled(int id, bool enabled); 338 static status_t moveEffectsToIo(const std::vector<int>& ids, audio_io_handle_t io); 339 340 // clear stream to output mapping cache (gStreamOutputMap) 341 // and output configuration cache (gOutputs) 342 static void clearAudioConfigCache(); 343 344 static const sp<media::IAudioPolicyService> get_audio_policy_service(); 345 346 // helpers for android.media.AudioManager.getProperty(), see description there for meaning 347 static uint32_t getPrimaryOutputSamplingRate(); 348 static size_t getPrimaryOutputFrameCount(); 349 350 static status_t setLowRamDevice(bool isLowRamDevice, int64_t totalMemory); 351 352 static status_t setSupportedSystemUsages(const std::vector<audio_usage_t>& systemUsages); 353 354 static status_t setAllowedCapturePolicy(uid_t uid, audio_flags_mask_t capturePolicy); 355 356 // Indicate if hw offload is possible for given format, stream type, sample rate, 357 // bit rate, duration, video and streaming or offload property is enabled and when possible 358 // if gapless transitions are supported. 359 static audio_offload_mode_t getOffloadSupport(const audio_offload_info_t& info); 360 361 // check presence of audio flinger service. 362 // returns NO_ERROR if binding to service succeeds, DEAD_OBJECT otherwise 363 static status_t checkAudioFlinger(); 364 365 /* List available audio ports and their attributes */ 366 static status_t listAudioPorts(audio_port_role_t role, 367 audio_port_type_t type, 368 unsigned int *num_ports, 369 struct audio_port_v7 *ports, 370 unsigned int *generation); 371 372 /* Get attributes for a given audio port */ 373 static status_t getAudioPort(struct audio_port_v7 *port); 374 375 /* Create an audio patch between several source and sink ports */ 376 static status_t createAudioPatch(const struct audio_patch *patch, 377 audio_patch_handle_t *handle); 378 379 /* Release an audio patch */ 380 static status_t releaseAudioPatch(audio_patch_handle_t handle); 381 382 /* List existing audio patches */ 383 static status_t listAudioPatches(unsigned int *num_patches, 384 struct audio_patch *patches, 385 unsigned int *generation); 386 /* Set audio port configuration */ 387 static status_t setAudioPortConfig(const struct audio_port_config *config); 388 389 390 static status_t acquireSoundTriggerSession(audio_session_t *session, 391 audio_io_handle_t *ioHandle, 392 audio_devices_t *device); 393 static status_t releaseSoundTriggerSession(audio_session_t session); 394 395 static audio_mode_t getPhoneState(); 396 397 static status_t registerPolicyMixes(const Vector<AudioMix>& mixes, bool registration); 398 399 static status_t setUidDeviceAffinities(uid_t uid, const AudioDeviceTypeAddrVector& devices); 400 401 static status_t removeUidDeviceAffinities(uid_t uid); 402 403 static status_t setUserIdDeviceAffinities(int userId, const AudioDeviceTypeAddrVector& devices); 404 405 static status_t removeUserIdDeviceAffinities(int userId); 406 407 static status_t startAudioSource(const struct audio_port_config *source, 408 const audio_attributes_t *attributes, 409 audio_port_handle_t *portId); 410 static status_t stopAudioSource(audio_port_handle_t portId); 411 412 static status_t setMasterMono(bool mono); 413 static status_t getMasterMono(bool *mono); 414 415 static status_t setMasterBalance(float balance); 416 static status_t getMasterBalance(float *balance); 417 418 static float getStreamVolumeDB( 419 audio_stream_type_t stream, int index, audio_devices_t device); 420 421 static status_t getMicrophones(std::vector<media::MicrophoneInfo> *microphones); 422 423 static status_t getHwOffloadEncodingFormatsSupportedForA2DP( 424 std::vector<audio_format_t> *formats); 425 426 // numSurroundFormats holds the maximum number of formats and bool value allowed in the array. 427 // When numSurroundFormats is 0, surroundFormats and surroundFormatsEnabled will not be 428 // populated. The actual number of surround formats should be returned at numSurroundFormats. 429 static status_t getSurroundFormats(unsigned int *numSurroundFormats, 430 audio_format_t *surroundFormats, 431 bool *surroundFormatsEnabled); 432 static status_t getReportedSurroundFormats(unsigned int *numSurroundFormats, 433 audio_format_t *surroundFormats); 434 static status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled); 435 436 static status_t setAssistantUid(uid_t uid); 437 static status_t setHotwordDetectionServiceUid(uid_t uid); 438 static status_t setA11yServicesUids(const std::vector<uid_t>& uids); 439 static status_t setCurrentImeUid(uid_t uid); 440 441 static bool isHapticPlaybackSupported(); 442 443 static status_t listAudioProductStrategies(AudioProductStrategyVector &strategies); 444 static status_t getProductStrategyFromAudioAttributes( 445 const AudioAttributes &aa, product_strategy_t &productStrategy, 446 bool fallbackOnDefault = true); 447 448 static audio_attributes_t streamTypeToAttributes(audio_stream_type_t stream); 449 static audio_stream_type_t attributesToStreamType(const audio_attributes_t &attr); 450 451 static status_t listAudioVolumeGroups(AudioVolumeGroupVector &groups); 452 453 static status_t getVolumeGroupFromAudioAttributes( 454 const AudioAttributes &aa, volume_group_t &volumeGroup, bool fallbackOnDefault = true); 455 456 static status_t setRttEnabled(bool enabled); 457 458 static bool isCallScreenModeSupported(); 459 460 /** 461 * Send audio HAL server process pids to native audioserver process for use 462 * when generating audio HAL servers tombstones 463 */ 464 static status_t setAudioHalPids(const std::vector<pid_t>& pids); 465 466 static status_t setDevicesRoleForStrategy(product_strategy_t strategy, 467 device_role_t role, const AudioDeviceTypeAddrVector &devices); 468 469 static status_t removeDevicesRoleForStrategy(product_strategy_t strategy, device_role_t role); 470 471 static status_t getDevicesForRoleAndStrategy(product_strategy_t strategy, 472 device_role_t role, AudioDeviceTypeAddrVector &devices); 473 474 static status_t setDevicesRoleForCapturePreset(audio_source_t audioSource, 475 device_role_t role, const AudioDeviceTypeAddrVector &devices); 476 477 static status_t addDevicesRoleForCapturePreset(audio_source_t audioSource, 478 device_role_t role, const AudioDeviceTypeAddrVector &devices); 479 480 static status_t removeDevicesRoleForCapturePreset( 481 audio_source_t audioSource, device_role_t role, 482 const AudioDeviceTypeAddrVector& devices); 483 484 static status_t clearDevicesRoleForCapturePreset( 485 audio_source_t audioSource, device_role_t role); 486 487 static status_t getDevicesForRoleAndCapturePreset(audio_source_t audioSource, 488 device_role_t role, AudioDeviceTypeAddrVector &devices); 489 490 static status_t getDeviceForStrategy(product_strategy_t strategy, 491 AudioDeviceTypeAddr &device); 492 493 494 /** 495 * If a spatializer stage effect is present on the platform, this will return an 496 * ISpatializer interface to control this feature. 497 * If no spatializer stage is present, a null interface is returned. 498 * The INativeSpatializerCallback passed must not be null. 499 * Only one ISpatializer interface can exist at a given time. The native audio policy 500 * service will reject the request if an interface was already acquired and previous owner 501 * did not die or call ISpatializer.release(). 502 * @param callback in: the callback to receive state updates if the ISpatializer 503 * interface is acquired. 504 * @param spatializer out: the ISpatializer interface made available to control the 505 * platform spatializer 506 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, PERMISSION_DENIED, BAD_VALUE 507 * in case of error. 508 */ 509 static status_t getSpatializer(const sp<media::INativeSpatializerCallback>& callback, 510 sp<media::ISpatializer>* spatializer); 511 512 /** 513 * Queries if some kind of spatialization will be performed if the audio playback context 514 * described by the provided arguments is present. 515 * The context is made of: 516 * - The audio attributes describing the playback use case. 517 * - The audio configuration describing the audio format, channels, sampling rate ... 518 * - The devices describing the sink audio device selected for playback. 519 * All arguments are optional and only the specified arguments are used to match against 520 * supported criteria. For instance, supplying no argument will tell if spatialization is 521 * supported or not in general. 522 * @param attr audio attributes describing the playback use case 523 * @param config audio configuration describing the audio format, channels, sampling rate... 524 * @param devices the sink audio device selected for playback 525 * @param canBeSpatialized out: true if spatialization is enabled for this context, 526 * false otherwise 527 * @return NO_ERROR in case of success, DEAD_OBJECT, NO_INIT, BAD_VALUE 528 * in case of error. 529 */ 530 static status_t canBeSpatialized(const audio_attributes_t *attr, 531 const audio_config_t *config, 532 const AudioDeviceTypeAddrVector &devices, 533 bool *canBeSpatialized); 534 535 536 // A listener for capture state changes. 537 class CaptureStateListener : public RefBase { 538 public: 539 // Called whenever capture state changes. 540 virtual void onStateChanged(bool active) = 0; 541 // Called whenever the service dies (and hence our listener is no longer 542 // registered). 543 virtual void onServiceDied() = 0; 544 545 virtual ~CaptureStateListener() = default; 546 }; 547 548 // Registers a listener for sound trigger capture state changes. 549 // There may only be one such listener registered at any point. 550 // The listener onStateChanged() method will be invoked synchronously from 551 // this call with the initial value. 552 // The listener onServiceDied() method will be invoked synchronously from 553 // this call if initial attempt to register failed. 554 // If the audio policy service cannot be reached, this method will return 555 // PERMISSION_DENIED and will not invoke the callback, otherwise, it will 556 // return NO_ERROR. 557 static status_t registerSoundTriggerCaptureStateListener( 558 const sp<CaptureStateListener>& listener); 559 560 // ---------------------------------------------------------------------------- 561 562 class AudioVolumeGroupCallback : public RefBase 563 { 564 public: 565 AudioVolumeGroupCallback()566 AudioVolumeGroupCallback() {} ~AudioVolumeGroupCallback()567 virtual ~AudioVolumeGroupCallback() {} 568 569 virtual void onAudioVolumeGroupChanged(volume_group_t group, int flags) = 0; 570 virtual void onServiceDied() = 0; 571 572 }; 573 574 static status_t addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback); 575 static status_t removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback); 576 577 class AudioPortCallback : public RefBase 578 { 579 public: 580 AudioPortCallback()581 AudioPortCallback() {} ~AudioPortCallback()582 virtual ~AudioPortCallback() {} 583 584 virtual void onAudioPortListUpdate() = 0; 585 virtual void onAudioPatchListUpdate() = 0; 586 virtual void onServiceDied() = 0; 587 588 }; 589 590 static status_t addAudioPortCallback(const sp<AudioPortCallback>& callback); 591 static status_t removeAudioPortCallback(const sp<AudioPortCallback>& callback); 592 593 class AudioDeviceCallback : public RefBase 594 { 595 public: 596 AudioDeviceCallback()597 AudioDeviceCallback() {} ~AudioDeviceCallback()598 virtual ~AudioDeviceCallback() {} 599 600 virtual void onAudioDeviceUpdate(audio_io_handle_t audioIo, 601 audio_port_handle_t deviceId) = 0; 602 }; 603 604 static status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 605 audio_io_handle_t audioIo, 606 audio_port_handle_t portId); 607 static status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 608 audio_io_handle_t audioIo, 609 audio_port_handle_t portId); 610 611 static audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo); 612 613 static status_t setVibratorInfos(const std::vector<media::AudioVibratorInfo>& vibratorInfos); 614 615 private: 616 617 class AudioFlingerClient: public IBinder::DeathRecipient, public media::BnAudioFlingerClient 618 { 619 public: AudioFlingerClient()620 AudioFlingerClient() : 621 mInBuffSize(0), mInSamplingRate(0), 622 mInFormat(AUDIO_FORMAT_DEFAULT), mInChannelMask(AUDIO_CHANNEL_NONE) { 623 } 624 625 void clearIoCache(); 626 status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, 627 audio_channel_mask_t channelMask, size_t* buffSize); 628 sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle); 629 630 // DeathRecipient 631 virtual void binderDied(const wp<IBinder>& who); 632 633 // IAudioFlingerClient 634 635 // indicate a change in the configuration of an output or input: keeps the cached 636 // values for output/input parameters up-to-date in client process 637 binder::Status ioConfigChanged( 638 media::AudioIoConfigEvent event, 639 const media::AudioIoDescriptor& ioDesc) override; 640 641 status_t addAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 642 audio_io_handle_t audioIo, 643 audio_port_handle_t portId); 644 status_t removeAudioDeviceCallback(const wp<AudioDeviceCallback>& callback, 645 audio_io_handle_t audioIo, 646 audio_port_handle_t portId); 647 648 audio_port_handle_t getDeviceIdForIo(audio_io_handle_t audioIo); 649 650 private: 651 Mutex mLock; 652 DefaultKeyedVector<audio_io_handle_t, sp<AudioIoDescriptor> > mIoDescriptors; 653 654 std::map<audio_io_handle_t, std::map<audio_port_handle_t, wp<AudioDeviceCallback>>> 655 mAudioDeviceCallbacks; 656 // cached values for recording getInputBufferSize() queries 657 size_t mInBuffSize; // zero indicates cache is invalid 658 uint32_t mInSamplingRate; 659 audio_format_t mInFormat; 660 audio_channel_mask_t mInChannelMask; 661 sp<AudioIoDescriptor> getIoDescriptor_l(audio_io_handle_t ioHandle); 662 }; 663 664 class AudioPolicyServiceClient: public IBinder::DeathRecipient, 665 public media::BnAudioPolicyServiceClient 666 { 667 public: AudioPolicyServiceClient()668 AudioPolicyServiceClient() { 669 } 670 671 int addAudioPortCallback(const sp<AudioPortCallback>& callback); 672 int removeAudioPortCallback(const sp<AudioPortCallback>& callback); isAudioPortCbEnabled()673 bool isAudioPortCbEnabled() const { return (mAudioPortCallbacks.size() != 0); } 674 675 int addAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback); 676 int removeAudioVolumeGroupCallback(const sp<AudioVolumeGroupCallback>& callback); isAudioVolumeGroupCbEnabled()677 bool isAudioVolumeGroupCbEnabled() const { return (mAudioVolumeGroupCallback.size() != 0); } 678 679 // DeathRecipient 680 virtual void binderDied(const wp<IBinder>& who); 681 682 // IAudioPolicyServiceClient 683 binder::Status onAudioVolumeGroupChanged(int32_t group, int32_t flags) override; 684 binder::Status onAudioPortListUpdate() override; 685 binder::Status onAudioPatchListUpdate() override; 686 binder::Status onDynamicPolicyMixStateUpdate(const std::string& regId, 687 int32_t state) override; 688 binder::Status onRecordingConfigurationUpdate( 689 int32_t event, 690 const media::RecordClientInfo& clientInfo, 691 const media::AudioConfigBase& clientConfig, 692 const std::vector<media::EffectDescriptor>& clientEffects, 693 const media::AudioConfigBase& deviceConfig, 694 const std::vector<media::EffectDescriptor>& effects, 695 int32_t patchHandle, 696 media::AudioSourceType source) override; 697 binder::Status onRoutingUpdated(); 698 699 private: 700 Mutex mLock; 701 Vector <sp <AudioPortCallback> > mAudioPortCallbacks; 702 Vector <sp <AudioVolumeGroupCallback> > mAudioVolumeGroupCallback; 703 }; 704 705 static audio_io_handle_t getOutput(audio_stream_type_t stream); 706 static const sp<AudioFlingerClient> getAudioFlingerClient(); 707 static sp<AudioIoDescriptor> getIoDescriptor(audio_io_handle_t ioHandle); 708 709 // Invokes all registered error callbacks with the given error code. 710 static void reportError(status_t err); 711 712 static sp<AudioFlingerClient> gAudioFlingerClient; 713 static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient; 714 friend class AudioFlingerClient; 715 friend class AudioPolicyServiceClient; 716 717 static Mutex gLock; // protects gAudioFlinger 718 static Mutex gLockErrorCallbacks; // protects gAudioErrorCallbacks 719 static Mutex gLockAPS; // protects gAudioPolicyService and gAudioPolicyServiceClient 720 static sp<IAudioFlinger> gAudioFlinger; 721 static std::set<audio_error_callback> gAudioErrorCallbacks; 722 static dynamic_policy_callback gDynPolicyCallback; 723 static record_config_callback gRecordConfigCallback; 724 static routing_callback gRoutingCallback; 725 726 static size_t gInBuffSize; 727 // previous parameters for recording buffer size queries 728 static uint32_t gPrevInSamplingRate; 729 static audio_format_t gPrevInFormat; 730 static audio_channel_mask_t gPrevInChannelMask; 731 732 static sp<media::IAudioPolicyService> gAudioPolicyService; 733 }; 734 735 }; // namespace android 736 737 #endif /*ANDROID_AUDIOSYSTEM_H_*/ 738