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