1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <atomic> 20 #include <memory> 21 #include <unordered_set> 22 23 #include <stdint.h> 24 #include <sys/types.h> 25 #include <cutils/config_utils.h> 26 #include <cutils/misc.h> 27 #include <utils/Timers.h> 28 #include <utils/Errors.h> 29 #include <utils/KeyedVector.h> 30 #include <utils/SortedVector.h> 31 #include <media/AudioParameter.h> 32 #include <media/AudioPolicy.h> 33 #include "AudioPolicyInterface.h" 34 35 #include <AudioPolicyManagerInterface.h> 36 #include <AudioPolicyManagerObserver.h> 37 #include <AudioGain.h> 38 #include <AudioPolicyConfig.h> 39 #include <AudioPort.h> 40 #include <AudioPatch.h> 41 #include <DeviceDescriptor.h> 42 #include <IOProfile.h> 43 #include <HwModule.h> 44 #include <AudioInputDescriptor.h> 45 #include <AudioOutputDescriptor.h> 46 #include <AudioPolicyMix.h> 47 #include <EffectDescriptor.h> 48 #include <SoundTriggerSession.h> 49 #include <SessionRoute.h> 50 #include <VolumeCurve.h> 51 52 namespace android { 53 54 // ---------------------------------------------------------------------------- 55 56 // Attenuation applied to STRATEGY_SONIFICATION streams when a headset is connected: 6dB 57 #define SONIFICATION_HEADSET_VOLUME_FACTOR_DB (-6) 58 // Min volume for STRATEGY_SONIFICATION streams when limited by music volume: -36dB 59 #define SONIFICATION_HEADSET_VOLUME_MIN_DB (-36) 60 // Max volume difference on A2DP between playing media and STRATEGY_SONIFICATION streams: 12dB 61 #define SONIFICATION_A2DP_MAX_MEDIA_DIFF_DB (12) 62 63 // Time in milliseconds during which we consider that music is still active after a music 64 // track was stopped - see computeVolume() 65 #define SONIFICATION_HEADSET_MUSIC_DELAY 5000 66 67 // Time in milliseconds during witch some streams are muted while the audio path 68 // is switched 69 #define MUTE_TIME_MS 2000 70 71 // multiplication factor applied to output latency when calculating a safe mute delay when 72 // invalidating tracks 73 #define LATENCY_MUTE_FACTOR 4 74 75 #define NUM_TEST_OUTPUTS 5 76 77 #define NUM_VOL_CURVE_KNEES 2 78 79 // Default minimum length allowed for offloading a compressed track 80 // Can be overridden by the audio.offload.min.duration.secs property 81 #define OFFLOAD_DEFAULT_MIN_DURATION_SECS 60 82 83 // ---------------------------------------------------------------------------- 84 // AudioPolicyManager implements audio policy manager behavior common to all platforms. 85 // ---------------------------------------------------------------------------- 86 87 class AudioPolicyManager : public AudioPolicyInterface, public AudioPolicyManagerObserver 88 { 89 90 public: 91 explicit AudioPolicyManager(AudioPolicyClientInterface *clientInterface); 92 virtual ~AudioPolicyManager(); 93 94 // AudioPolicyInterface 95 virtual status_t setDeviceConnectionState(audio_devices_t device, 96 audio_policy_dev_state_t state, 97 const char *device_address, 98 const char *device_name); 99 virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, 100 const char *device_address); 101 virtual status_t handleDeviceConfigChange(audio_devices_t device, 102 const char *device_address, 103 const char *device_name); 104 virtual void setPhoneState(audio_mode_t state); 105 virtual void setForceUse(audio_policy_force_use_t usage, 106 audio_policy_forced_cfg_t config); 107 virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); 108 109 virtual void setSystemProperty(const char* property, const char* value); 110 virtual status_t initCheck(); 111 virtual audio_io_handle_t getOutput(audio_stream_type_t stream); 112 virtual status_t getOutputForAttr(const audio_attributes_t *attr, 113 audio_io_handle_t *output, 114 audio_session_t session, 115 audio_stream_type_t *stream, 116 uid_t uid, 117 const audio_config_t *config, 118 audio_output_flags_t *flags, 119 audio_port_handle_t *selectedDeviceId, 120 audio_port_handle_t *portId); 121 virtual status_t startOutput(audio_io_handle_t output, 122 audio_stream_type_t stream, 123 audio_session_t session); 124 virtual status_t stopOutput(audio_io_handle_t output, 125 audio_stream_type_t stream, 126 audio_session_t session); 127 virtual void releaseOutput(audio_io_handle_t output, 128 audio_stream_type_t stream, 129 audio_session_t session); 130 virtual status_t getInputForAttr(const audio_attributes_t *attr, 131 audio_io_handle_t *input, 132 audio_session_t session, 133 uid_t uid, 134 const audio_config_base_t *config, 135 audio_input_flags_t flags, 136 audio_port_handle_t *selectedDeviceId, 137 input_type_t *inputType, 138 audio_port_handle_t *portId); 139 140 // indicates to the audio policy manager that the input starts being used. 141 virtual status_t startInput(audio_io_handle_t input, 142 audio_session_t session, 143 bool silenced, 144 concurrency_type__mask_t *concurrency); 145 146 // indicates to the audio policy manager that the input stops being used. 147 virtual status_t stopInput(audio_io_handle_t input, 148 audio_session_t session); 149 virtual void releaseInput(audio_io_handle_t input, 150 audio_session_t session); 151 virtual void closeAllInputs(); 152 virtual void initStreamVolume(audio_stream_type_t stream, 153 int indexMin, 154 int indexMax); 155 virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, 156 int index, 157 audio_devices_t device); 158 virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, 159 int *index, 160 audio_devices_t device); 161 162 // return the strategy corresponding to a given stream type 163 virtual uint32_t getStrategyForStream(audio_stream_type_t stream); 164 // return the strategy corresponding to the given audio attributes 165 virtual uint32_t getStrategyForAttr(const audio_attributes_t *attr); 166 167 // return the enabled output devices for the given stream type 168 virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream); 169 170 virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL); 171 virtual status_t registerEffect(const effect_descriptor_t *desc, 172 audio_io_handle_t io, 173 uint32_t strategy, 174 int session, 175 int id); unregisterEffect(int id)176 virtual status_t unregisterEffect(int id) 177 { 178 return mEffects.unregisterEffect(id); 179 } setEffectEnabled(int id,bool enabled)180 virtual status_t setEffectEnabled(int id, bool enabled) 181 { 182 return mEffects.setEffectEnabled(id, enabled); 183 } 184 185 virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const; 186 // return whether a stream is playing remotely, override to change the definition of 187 // local/remote playback, used for instance by notification manager to not make 188 // media players lose audio focus when not playing locally 189 // For the base implementation, "remotely" means playing during screen mirroring which 190 // uses an output for playback with a non-empty, non "0" address. 191 virtual bool isStreamActiveRemotely(audio_stream_type_t stream, 192 uint32_t inPastMs = 0) const; 193 194 virtual bool isSourceActive(audio_source_t source) const; 195 196 virtual status_t dump(int fd); 197 198 virtual bool isOffloadSupported(const audio_offload_info_t& offloadInfo); 199 200 virtual status_t listAudioPorts(audio_port_role_t role, 201 audio_port_type_t type, 202 unsigned int *num_ports, 203 struct audio_port *ports, 204 unsigned int *generation); 205 virtual status_t getAudioPort(struct audio_port *port); 206 virtual status_t createAudioPatch(const struct audio_patch *patch, 207 audio_patch_handle_t *handle, 208 uid_t uid); 209 virtual status_t releaseAudioPatch(audio_patch_handle_t handle, 210 uid_t uid); 211 virtual status_t listAudioPatches(unsigned int *num_patches, 212 struct audio_patch *patches, 213 unsigned int *generation); 214 virtual status_t setAudioPortConfig(const struct audio_port_config *config); 215 216 virtual void releaseResourcesForUid(uid_t uid); 217 218 virtual status_t acquireSoundTriggerSession(audio_session_t *session, 219 audio_io_handle_t *ioHandle, 220 audio_devices_t *device); 221 releaseSoundTriggerSession(audio_session_t session)222 virtual status_t releaseSoundTriggerSession(audio_session_t session) 223 { 224 return mSoundTriggerSessions.releaseSession(session); 225 } 226 227 virtual status_t registerPolicyMixes(const Vector<AudioMix>& mixes); 228 virtual status_t unregisterPolicyMixes(Vector<AudioMix> mixes); 229 230 virtual status_t startAudioSource(const struct audio_port_config *source, 231 const audio_attributes_t *attributes, 232 audio_patch_handle_t *handle, 233 uid_t uid); 234 virtual status_t stopAudioSource(audio_patch_handle_t handle); 235 236 virtual status_t setMasterMono(bool mono); 237 virtual status_t getMasterMono(bool *mono); 238 virtual float getStreamVolumeDB( 239 audio_stream_type_t stream, int index, audio_devices_t device); 240 241 virtual status_t getSurroundFormats(unsigned int *numSurroundFormats, 242 audio_format_t *surroundFormats, 243 bool *surroundFormatsEnabled, 244 bool reported); 245 virtual status_t setSurroundFormatEnabled(audio_format_t audioFormat, bool enabled); 246 247 // return the strategy corresponding to a given stream type 248 routing_strategy getStrategy(audio_stream_type_t stream) const; 249 250 virtual void setRecordSilenced(uid_t uid, bool silenced); 251 252 protected: 253 // A constructor that allows more fine-grained control over initialization process, 254 // used in automatic tests. 255 AudioPolicyManager(AudioPolicyClientInterface *clientInterface, bool forTesting); 256 257 // These methods should be used when finer control over APM initialization 258 // is needed, e.g. in tests. Must be used in conjunction with the constructor 259 // that only performs fields initialization. The public constructor comprises 260 // these steps in the following sequence: 261 // - field initializing constructor; 262 // - loadConfig; 263 // - initialize. getConfig()264 AudioPolicyConfig& getConfig() { return mConfig; } 265 void loadConfig(); 266 status_t initialize(); 267 268 // From AudioPolicyManagerObserver getAudioPatches()269 virtual const AudioPatchCollection &getAudioPatches() const 270 { 271 return mAudioPatches; 272 } getSoundTriggerSessionCollection()273 virtual const SoundTriggerSessionCollection &getSoundTriggerSessionCollection() const 274 { 275 return mSoundTriggerSessions; 276 } getAudioPolicyMixCollection()277 virtual const AudioPolicyMixCollection &getAudioPolicyMixCollection() const 278 { 279 return mPolicyMixes; 280 } getOutputs()281 virtual const SwAudioOutputCollection &getOutputs() const 282 { 283 return mOutputs; 284 } getInputs()285 virtual const AudioInputCollection &getInputs() const 286 { 287 return mInputs; 288 } getAvailableOutputDevices()289 virtual const DeviceVector &getAvailableOutputDevices() const 290 { 291 return mAvailableOutputDevices; 292 } getAvailableInputDevices()293 virtual const DeviceVector &getAvailableInputDevices() const 294 { 295 return mAvailableInputDevices; 296 } getVolumeCurves()297 virtual IVolumeCurvesCollection &getVolumeCurves() { return *mVolumeCurves; } getDefaultOutputDevice()298 virtual const sp<DeviceDescriptor> &getDefaultOutputDevice() const 299 { 300 return mDefaultOutputDevice; 301 } 302 303 void addOutput(audio_io_handle_t output, const sp<SwAudioOutputDescriptor>& outputDesc); 304 void removeOutput(audio_io_handle_t output); 305 void addInput(audio_io_handle_t input, const sp<AudioInputDescriptor>& inputDesc); 306 307 // return appropriate device for streams handled by the specified strategy according to current 308 // phone state, connected devices... 309 // if fromCache is true, the device is returned from mDeviceForStrategy[], 310 // otherwise it is determine by current state 311 // (device connected,phone state, force use, a2dp output...) 312 // This allows to: 313 // 1 speed up process when the state is stable (when starting or stopping an output) 314 // 2 access to either current device selection (fromCache == true) or 315 // "future" device selection (fromCache == false) when called from a context 316 // where conditions are changing (setDeviceConnectionState(), setPhoneState()...) AND 317 // before updateDevicesAndOutputs() is called. 318 virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy, 319 bool fromCache); 320 321 bool isStrategyActive(const sp<AudioOutputDescriptor>& outputDesc, routing_strategy strategy, 322 uint32_t inPastMs = 0, nsecs_t sysTime = 0) const; 323 324 // change the route of the specified output. Returns the number of ms we have slept to 325 // allow new routing to take effect in certain cases. 326 virtual uint32_t setOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 327 audio_devices_t device, 328 bool force = false, 329 int delayMs = 0, 330 audio_patch_handle_t *patchHandle = NULL, 331 const char *address = nullptr, 332 bool requiresMuteCheck = true); 333 status_t resetOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 334 int delayMs = 0, 335 audio_patch_handle_t *patchHandle = NULL); 336 status_t setInputDevice(audio_io_handle_t input, 337 audio_devices_t device, 338 bool force = false, 339 audio_patch_handle_t *patchHandle = NULL); 340 status_t resetInputDevice(audio_io_handle_t input, 341 audio_patch_handle_t *patchHandle = NULL); 342 343 // select input device corresponding to requested audio source 344 virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource); 345 346 // compute the actual volume for a given stream according to the requested index and a particular 347 // device 348 virtual float computeVolume(audio_stream_type_t stream, 349 int index, 350 audio_devices_t device); 351 352 // check that volume change is permitted, compute and send new volume to audio hardware 353 virtual status_t checkAndSetVolume(audio_stream_type_t stream, int index, 354 const sp<AudioOutputDescriptor>& outputDesc, 355 audio_devices_t device, 356 int delayMs = 0, bool force = false); 357 358 // apply all stream volumes to the specified output and device 359 void applyStreamVolumes(const sp<AudioOutputDescriptor>& outputDesc, 360 audio_devices_t device, int delayMs = 0, bool force = false); 361 362 // Mute or unmute all streams handled by the specified strategy on the specified output 363 void setStrategyMute(routing_strategy strategy, 364 bool on, 365 const sp<AudioOutputDescriptor>& outputDesc, 366 int delayMs = 0, 367 audio_devices_t device = (audio_devices_t)0); 368 369 // Mute or unmute the stream on the specified output 370 void setStreamMute(audio_stream_type_t stream, 371 bool on, 372 const sp<AudioOutputDescriptor>& outputDesc, 373 int delayMs = 0, 374 audio_devices_t device = (audio_devices_t)0); 375 376 // handle special cases for sonification strategy while in call: mute streams or replace by 377 // a special tone in the device used for communication 378 void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange); 379 380 audio_mode_t getPhoneState(); 381 382 // true if device is in a telephony or VoIP call 383 virtual bool isInCall(); 384 // true if given state represents a device in a telephony or VoIP call 385 virtual bool isStateInCall(int state); 386 387 // when a device is connected, checks if an open output can be routed 388 // to this device. If none is open, tries to open one of the available outputs. 389 // Returns an output suitable to this device or 0. 390 // when a device is disconnected, checks if an output is not used any more and 391 // returns its handle if any. 392 // transfers the audio tracks and effects from one output thread to another accordingly. 393 status_t checkOutputsForDevice(const sp<DeviceDescriptor>& devDesc, 394 audio_policy_dev_state_t state, 395 SortedVector<audio_io_handle_t>& outputs, 396 const String8& address); 397 398 status_t checkInputsForDevice(const sp<DeviceDescriptor>& devDesc, 399 audio_policy_dev_state_t state, 400 SortedVector<audio_io_handle_t>& inputs, 401 const String8& address); 402 403 // close an output and its companion duplicating output. 404 void closeOutput(audio_io_handle_t output); 405 406 // close an input. 407 void closeInput(audio_io_handle_t input); 408 409 // checks and if necessary changes outputs used for all strategies. 410 // must be called every time a condition that affects the output choice for a given strategy 411 // changes: connected device, phone state, force use... 412 // Must be called before updateDevicesAndOutputs() 413 void checkOutputForStrategy(routing_strategy strategy); 414 415 // Same as checkOutputForStrategy() but for a all strategies in order of priority 416 void checkOutputForAllStrategies(); 417 418 // manages A2DP output suspend/restore according to phone state and BT SCO usage 419 void checkA2dpSuspend(); 420 421 // selects the most appropriate device on output for current state 422 // must be called every time a condition that affects the device choice for a given output is 423 // changed: connected device, phone state, force use, output start, output stop.. 424 // see getDeviceForStrategy() for the use of fromCache parameter 425 audio_devices_t getNewOutputDevice(const sp<AudioOutputDescriptor>& outputDesc, 426 bool fromCache); 427 428 // updates cache of device used by all strategies (mDeviceForStrategy[]) 429 // must be called every time a condition that affects the device choice for a given strategy is 430 // changed: connected device, phone state, force use... 431 // cached values are used by getDeviceForStrategy() if parameter fromCache is true. 432 // Must be called after checkOutputForAllStrategies() 433 void updateDevicesAndOutputs(); 434 435 // selects the most appropriate device on input for current state 436 audio_devices_t getNewInputDevice(const sp<AudioInputDescriptor>& inputDesc); 437 getMaxEffectsCpuLoad()438 virtual uint32_t getMaxEffectsCpuLoad() 439 { 440 return mEffects.getMaxEffectsCpuLoad(); 441 } 442 getMaxEffectsMemory()443 virtual uint32_t getMaxEffectsMemory() 444 { 445 return mEffects.getMaxEffectsMemory(); 446 } 447 448 SortedVector<audio_io_handle_t> getOutputsForDevice(audio_devices_t device, 449 const SwAudioOutputCollection& openOutputs); 450 bool vectorsEqual(SortedVector<audio_io_handle_t>& outputs1, 451 SortedVector<audio_io_handle_t>& outputs2); 452 453 // mute/unmute strategies using an incompatible device combination 454 // if muting, wait for the audio in pcm buffer to be drained before proceeding 455 // if unmuting, unmute only after the specified delay 456 // Returns the number of ms waited 457 virtual uint32_t checkDeviceMuteStrategies(const sp<AudioOutputDescriptor>& outputDesc, 458 audio_devices_t prevDevice, 459 uint32_t delayMs); 460 461 audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs, 462 audio_output_flags_t flags, 463 audio_format_t format); 464 // samplingRate, format, channelMask are in/out and so may be modified 465 sp<IOProfile> getInputProfile(audio_devices_t device, 466 const String8& address, 467 uint32_t& samplingRate, 468 audio_format_t& format, 469 audio_channel_mask_t& channelMask, 470 audio_input_flags_t flags); 471 sp<IOProfile> getProfileForDirectOutput(audio_devices_t device, 472 uint32_t samplingRate, 473 audio_format_t format, 474 audio_channel_mask_t channelMask, 475 audio_output_flags_t flags); 476 477 audio_io_handle_t selectOutputForMusicEffects(); 478 addAudioPatch(audio_patch_handle_t handle,const sp<AudioPatch> & patch)479 virtual status_t addAudioPatch(audio_patch_handle_t handle, const sp<AudioPatch>& patch) 480 { 481 return mAudioPatches.addAudioPatch(handle, patch); 482 } removeAudioPatch(audio_patch_handle_t handle)483 virtual status_t removeAudioPatch(audio_patch_handle_t handle) 484 { 485 return mAudioPatches.removeAudioPatch(handle); 486 } 487 availablePrimaryOutputDevices()488 audio_devices_t availablePrimaryOutputDevices() const 489 { 490 if (!hasPrimaryOutput()) { 491 return AUDIO_DEVICE_NONE; 492 } 493 return mPrimaryOutput->supportedDevices() & mAvailableOutputDevices.types(); 494 } availablePrimaryInputDevices()495 audio_devices_t availablePrimaryInputDevices() const 496 { 497 if (!hasPrimaryOutput()) { 498 return AUDIO_DEVICE_NONE; 499 } 500 return mAvailableInputDevices.getDevicesFromHwModule(mPrimaryOutput->getModuleHandle()); 501 } 502 503 uint32_t updateCallRouting(audio_devices_t rxDevice, uint32_t delayMs = 0); 504 sp<AudioPatch> createTelephonyPatch(bool isRx, audio_devices_t device, uint32_t delayMs); 505 sp<DeviceDescriptor> fillAudioPortConfigForDevice( 506 const DeviceVector& devices, audio_devices_t device, audio_port_config *config); 507 508 // if argument "device" is different from AUDIO_DEVICE_NONE, startSource() will force 509 // the re-evaluation of the output device. 510 status_t startSource(const sp<AudioOutputDescriptor>& outputDesc, 511 audio_stream_type_t stream, 512 audio_devices_t device, 513 const char *address, 514 uint32_t *delayMs); 515 status_t stopSource(const sp<AudioOutputDescriptor>& outputDesc, 516 audio_stream_type_t stream, 517 bool forceDeviceUpdate); 518 519 void clearAudioPatches(uid_t uid); 520 void clearSessionRoutes(uid_t uid); 521 void checkStrategyRoute(routing_strategy strategy, audio_io_handle_t ouptutToSkip); 522 hasPrimaryOutput()523 status_t hasPrimaryOutput() const { return mPrimaryOutput != 0; } 524 525 status_t connectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc); 526 status_t disconnectAudioSource(const sp<AudioSourceDescriptor>& sourceDesc); 527 528 sp<AudioSourceDescriptor> getSourceForStrategyOnOutput(audio_io_handle_t output, 529 routing_strategy strategy); 530 531 void cleanUpForDevice(const sp<DeviceDescriptor>& deviceDesc); 532 533 void clearAudioSources(uid_t uid); 534 535 static bool isConcurrentSource(audio_source_t source); 536 537 bool isConcurentCaptureAllowed(const sp<AudioInputDescriptor>& inputDesc, 538 const sp<AudioSession>& audioSession); 539 540 static bool streamsMatchForvolume(audio_stream_type_t stream1, 541 audio_stream_type_t stream2); 542 543 uid_t mUidCached; 544 AudioPolicyClientInterface *mpClientInterface; // audio policy client interface 545 sp<SwAudioOutputDescriptor> mPrimaryOutput; // primary output descriptor 546 // list of descriptors for outputs currently opened 547 548 SwAudioOutputCollection mOutputs; 549 // copy of mOutputs before setDeviceConnectionState() opens new outputs 550 // reset to mOutputs when updateDevicesAndOutputs() is called. 551 SwAudioOutputCollection mPreviousOutputs; 552 AudioInputCollection mInputs; // list of input descriptors 553 554 DeviceVector mAvailableOutputDevices; // all available output devices 555 DeviceVector mAvailableInputDevices; // all available input devices 556 557 SessionRouteMap mOutputRoutes = SessionRouteMap(SessionRouteMap::MAPTYPE_OUTPUT); 558 SessionRouteMap mInputRoutes = SessionRouteMap(SessionRouteMap::MAPTYPE_INPUT); 559 560 bool mLimitRingtoneVolume; // limit ringtone volume to music volume if headset connected 561 audio_devices_t mDeviceForStrategy[NUM_STRATEGIES]; 562 float mLastVoiceVolume; // last voice volume value sent to audio HAL 563 bool mA2dpSuspended; // true if A2DP output is suspended 564 565 std::unique_ptr<IVolumeCurvesCollection> mVolumeCurves; // Volume Curves per use case and device category 566 EffectDescriptorCollection mEffects; // list of registered audio effects 567 sp<DeviceDescriptor> mDefaultOutputDevice; // output device selected by default at boot time 568 HwModuleCollection mHwModules; // contains only modules that have been loaded successfully 569 HwModuleCollection mHwModulesAll; // normally not needed, used during construction and for 570 // dumps 571 AudioPolicyConfig mConfig; 572 573 std::atomic<uint32_t> mAudioPortGeneration; 574 575 AudioPatchCollection mAudioPatches; 576 577 SoundTriggerSessionCollection mSoundTriggerSessions; 578 579 sp<AudioPatch> mCallTxPatch; 580 sp<AudioPatch> mCallRxPatch; 581 582 HwAudioOutputCollection mHwOutputs; 583 AudioSourceCollection mAudioSources; 584 585 // for supporting "beacon" streams, i.e. streams that only play on speaker, and never 586 // when something other than STREAM_TTS (a.k.a. "Transmitted Through Speaker") is playing 587 enum { 588 STARTING_OUTPUT, 589 STARTING_BEACON, 590 STOPPING_OUTPUT, 591 STOPPING_BEACON 592 }; 593 uint32_t mBeaconMuteRefCount; // ref count for stream that would mute beacon 594 uint32_t mBeaconPlayingRefCount;// ref count for the playing beacon streams 595 bool mBeaconMuted; // has STREAM_TTS been muted 596 bool mTtsOutputAvailable; // true if a dedicated output for TTS stream is available 597 598 bool mMasterMono; // true if we wish to force all outputs to mono 599 AudioPolicyMixCollection mPolicyMixes; // list of registered mixes 600 audio_io_handle_t mMusicEffectOutput; // output selected for music effects 601 602 uint32_t nextAudioPortGeneration(); 603 604 // Audio Policy Engine Interface. 605 AudioPolicyManagerInterface *mEngine; 606 607 // Surround formats that are enabled. 608 std::unordered_set<audio_format_t> mSurroundFormats; 609 private: 610 // Add or remove AC3 DTS encodings based on user preferences. 611 void filterSurroundFormats(FormatVector *formatsPtr); 612 void filterSurroundChannelMasks(ChannelsVector *channelMasksPtr); 613 614 status_t getSupportedFormats(audio_io_handle_t ioHandle, FormatVector& formats); 615 616 // If any, resolve any "dynamic" fields of an Audio Profiles collection 617 void updateAudioProfiles(audio_devices_t device, audio_io_handle_t ioHandle, 618 AudioProfileVector &profiles); 619 620 // Notify the policy client of any change of device state with AUDIO_IO_HANDLE_NONE, 621 // so that the client interprets it as global to audio hardware interfaces. 622 // It can give a chance to HAL implementer to retrieve dynamic capabilities associated 623 // to this device for example. 624 // TODO avoid opening stream to retrieve capabilities of a profile. 625 void broadcastDeviceConnectionState(audio_devices_t device, 626 audio_policy_dev_state_t state, 627 const String8 &device_address); 628 629 // updates device caching and output for streams that can influence the 630 // routing of notifications 631 void handleNotificationRoutingForStream(audio_stream_type_t stream); 632 // find the outputs on a given output descriptor that have the given address. 633 // to be called on an AudioOutputDescriptor whose supported devices (as defined 634 // in mProfile->mSupportedDevices) matches the device whose address is to be matched. 635 // see deviceDistinguishesOnAddress(audio_devices_t) for whether the device type is one 636 // where addresses are used to distinguish between one connected device and another. 637 void findIoHandlesByAddress(const sp<SwAudioOutputDescriptor>& desc /*in*/, 638 const audio_devices_t device /*in*/, 639 const String8& address /*in*/, 640 SortedVector<audio_io_handle_t>& outputs /*out*/); curAudioPortGeneration()641 uint32_t curAudioPortGeneration() const { return mAudioPortGeneration; } 642 // internal method to return the output handle for the given device and format 643 audio_io_handle_t getOutputForDevice( 644 audio_devices_t device, 645 audio_session_t session, 646 audio_stream_type_t stream, 647 const audio_config_t *config, 648 audio_output_flags_t *flags); 649 // internal method to return the input handle for the given device and format 650 audio_io_handle_t getInputForDevice(audio_devices_t device, 651 String8 address, 652 audio_session_t session, 653 uid_t uid, 654 audio_source_t inputSource, 655 const audio_config_base_t *config, 656 audio_input_flags_t flags, 657 AudioMix *policyMix); 658 659 // internal function to derive a stream type value from audio attributes 660 audio_stream_type_t streamTypefromAttributesInt(const audio_attributes_t *attr); 661 // event is one of STARTING_OUTPUT, STARTING_BEACON, STOPPING_OUTPUT, STOPPING_BEACON 662 // returns 0 if no mute/unmute event happened, the largest latency of the device where 663 // the mute/unmute happened 664 uint32_t handleEventForBeacon(int event); 665 uint32_t setBeaconMute(bool mute); 666 bool isValidAttributes(const audio_attributes_t *paa); 667 668 // select input device corresponding to requested audio source and return associated policy 669 // mix if any. Calls getDeviceForInputSource(). 670 audio_devices_t getDeviceAndMixForInputSource(audio_source_t inputSource, 671 AudioMix **policyMix = NULL); 672 673 // Called by setDeviceConnectionState(). 674 status_t setDeviceConnectionStateInt(audio_devices_t device, 675 audio_policy_dev_state_t state, 676 const char *device_address, 677 const char *device_name); updateMono(audio_io_handle_t output)678 void updateMono(audio_io_handle_t output) { 679 AudioParameter param; 680 param.addInt(String8(AudioParameter::keyMonoOutput), (int)mMasterMono); 681 mpClientInterface->setParameters(output, param.toString()); 682 } 683 684 bool soundTriggerSupportsConcurrentCapture(); 685 bool mSoundTriggerSupportsConcurrentCapture; 686 bool mHasComputedSoundTriggerSupportsConcurrentCapture; 687 }; 688 689 }; 690