Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3b73df74 authored by Eric Laurent's avatar Eric Laurent
Browse files

audio policy: remove dependency from AudioSystemLegacy 

Remove all dependencies on AudioSystemLegacy from AudioPolicyManagerBase.
Only use types and definitions from audio.h and audio_policy.h.
Also move code back into android name space.

Change-Id: I0c2582cf854027fb1e599981865a6cbe7b5a9490
parent e552edb3

services/audiopolicy/AudioPolicyInterface.h

+24 −28
Original line number Diff line number Diff line
@@ -18,16 +18,11 @@ 
#define ANDROID_AUDIOPOLICYINTERFACE_H



#include <media/AudioSystem.h>

#include <media/ToneGenerator.h>

#include <utils/String8.h>



#include <hardware_legacy/AudioSystemLegacy.h>

#include <hardware/audio_policy.h>



namespace android_audio_legacy {

    using android::Vector;

    using android::String8;

    using android::ToneGenerator;

namespace android {



// ----------------------------------------------------------------------------
@@ -68,17 +63,17 @@ public: 


    // indicate a change in device connection status

    virtual status_t setDeviceConnectionState(audio_devices_t device,

                                          AudioSystem::device_connection_state state,

                                              audio_policy_dev_state_t state,

                                          const char *device_address) = 0;

    // retrieve a device connection status

    virtual AudioSystem::device_connection_state getDeviceConnectionState(audio_devices_t device,

    virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,

                                                                          const char *device_address) = 0;

    // indicate a change in phone state. Valid phones states are defined by AudioSystem::audio_mode

    virtual void setPhoneState(int state) = 0;

    // indicate a change in phone state. Valid phones states are defined by audio_mode_t

    virtual void setPhoneState(audio_mode_t state) = 0;

    // force using a specific device category for the specified usage

    virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) = 0;

    virtual void setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) = 0;

    // retrieve current device category forced for a given usage

    virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage) = 0;

    virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0;

    // set a system property (e.g. camera sound always audible)

    virtual void setSystemProperty(const char* property, const char* value) = 0;

    // check proper initialization
@@ -89,29 +84,29 @@ public: 
    //



    // request an output appropriate for playback of the supplied stream type and parameters

    virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,

    virtual audio_io_handle_t getOutput(audio_stream_type_t stream,

                                        uint32_t samplingRate,

                                        audio_format_t format,

                                        audio_channel_mask_t channelMask,

                                        AudioSystem::output_flags flags,

                                        audio_output_flags_t flags,

                                        const audio_offload_info_t *offloadInfo) = 0;

    // indicates to the audio policy manager that the output starts being used by corresponding stream.

    virtual status_t startOutput(audio_io_handle_t output,

                                 AudioSystem::stream_type stream,

                                 audio_stream_type_t stream,

                                 int session = 0) = 0;

    // indicates to the audio policy manager that the output stops being used by corresponding stream.

    virtual status_t stopOutput(audio_io_handle_t output,

                                AudioSystem::stream_type stream,

                                audio_stream_type_t stream,

                                int session = 0) = 0;

    // releases the output.

    virtual void releaseOutput(audio_io_handle_t output) = 0;



    // request an input appropriate for record from the supplied device with supplied parameters.

    virtual audio_io_handle_t getInput(int inputSource,

    virtual audio_io_handle_t getInput(audio_source_t inputSource,

                                    uint32_t samplingRate,

                                    audio_format_t format,

                                    audio_channel_mask_t channelMask,

                                    AudioSystem::audio_in_acoustics acoustics) = 0;

                                    audio_in_acoustics_t acoustics) = 0;

    // indicates to the audio policy manager that the input starts being used.

    virtual status_t startInput(audio_io_handle_t input) = 0;

    // indicates to the audio policy manager that the input stops being used.
@@ -124,29 +119,29 @@ public: 
    //



    // initialises stream volume conversion parameters by specifying volume index range.

    virtual void initStreamVolume(AudioSystem::stream_type stream,

    virtual void initStreamVolume(audio_stream_type_t stream,

                                      int indexMin,

                                      int indexMax) = 0;



    // sets the new stream volume at a level corresponding to the supplied index for the

    // supplied device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means

    // setting volume for all devices

    virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream,

    virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,

                                          int index,

                                          audio_devices_t device) = 0;



    // retrieve current volume index for the specified stream and the

    // specified device. By convention, specifying AUDIO_DEVICE_OUT_DEFAULT means

    // querying the volume of the active device.

    virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream,

    virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,

                                          int *index,

                                          audio_devices_t device) = 0;



    // return the strategy corresponding to a given stream type

    virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream) = 0;

    virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0;



    // return the enabled output devices for the given stream type

    virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream) = 0;

    virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream) = 0;



    // Audio effect management

    virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc) = 0;
@@ -158,8 +153,9 @@ public: 
    virtual status_t unregisterEffect(int id) = 0;

    virtual status_t setEffectEnabled(int id, bool enabled) = 0;



    virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const = 0;

    virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const = 0;

    virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const = 0;

    virtual bool isStreamActiveRemotely(audio_stream_type_t stream,

                                        uint32_t inPastMs = 0) const = 0;

    virtual bool isSourceActive(audio_source_t source) const = 0;



    //dump state
@@ -227,10 +223,10 @@ public: 


    // set a stream volume for a particular output. For the same user setting, a given stream type can have different volumes

    // for each output (destination device) it is attached to.

    virtual status_t setStreamVolume(AudioSystem::stream_type stream, float volume, audio_io_handle_t output, int delayMs = 0) = 0;

    virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0) = 0;



    // invalidate a stream type, causing a reroute to an unspecified new output

    virtual status_t invalidateStream(AudioSystem::stream_type stream) = 0;

    virtual status_t invalidateStream(audio_stream_type_t stream) = 0;



    // function enabling to send proprietary informations directly from audio policy manager to audio hardware interface.

    virtual void setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs, int delayMs = 0) = 0;
@@ -239,7 +235,7 @@ public: 


    // request the playback of a tone on the specified stream: used for instance to replace notification sounds when playing

    // over a telephony device during a phone call.

    virtual status_t startTone(ToneGenerator::tone_type tone, AudioSystem::stream_type stream) = 0;

    virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream) = 0;

    virtual status_t stopTone() = 0;



    // set down link audio volume.

services/audiopolicy/AudioPolicyManagerBase.cpp

+187 −174

File changed.

Preview size limit exceeded, changes collapsed.

services/audiopolicy/AudioPolicyManagerBase.h

+41 −41
Original line number Diff line number Diff line
@@ -23,13 +23,10 @@ 
#include <utils/Errors.h>

#include <utils/KeyedVector.h>

#include <utils/SortedVector.h>

#include <hardware_legacy/AudioPolicyInterface.h>

#include "AudioPolicyInterface.h"





namespace android_audio_legacy {

    using android::KeyedVector;

    using android::DefaultKeyedVector;

    using android::SortedVector;

namespace android {



// ----------------------------------------------------------------------------
@@ -77,33 +74,34 @@ public: 


        // AudioPolicyInterface

        virtual status_t setDeviceConnectionState(audio_devices_t device,

                                                          AudioSystem::device_connection_state state,

                                                          audio_policy_dev_state_t state,

                                                          const char *device_address);

        virtual AudioSystem::device_connection_state getDeviceConnectionState(audio_devices_t device,

        virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device,

                                                                              const char *device_address);

        virtual void setPhoneState(int state);

        virtual void setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config);

        virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage);

        virtual void setPhoneState(audio_mode_t state);

        virtual void setForceUse(audio_policy_force_use_t usage,

                                 audio_policy_forced_cfg_t config);

        virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);

        virtual void setSystemProperty(const char* property, const char* value);

        virtual status_t initCheck();

        virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,

        virtual audio_io_handle_t getOutput(audio_stream_type_t stream,

                                            uint32_t samplingRate,

                                            audio_format_t format,

                                            audio_channel_mask_t channelMask,

                                            AudioSystem::output_flags flags,

                                            audio_output_flags_t flags,

                                            const audio_offload_info_t *offloadInfo);

        virtual status_t startOutput(audio_io_handle_t output,

                                     AudioSystem::stream_type stream,

                                     audio_stream_type_t stream,

                                     int session = 0);

        virtual status_t stopOutput(audio_io_handle_t output,

                                    AudioSystem::stream_type stream,

                                    audio_stream_type_t stream,

                                    int session = 0);

        virtual void releaseOutput(audio_io_handle_t output);

        virtual audio_io_handle_t getInput(int inputSource,

        virtual audio_io_handle_t getInput(audio_source_t inputSource,

                                            uint32_t samplingRate,

                                            audio_format_t format,

                                            audio_channel_mask_t channelMask,

                                            AudioSystem::audio_in_acoustics acoustics);

                                            audio_in_acoustics_t acoustics);



        // indicates to the audio policy manager that the input starts being used.

        virtual status_t startInput(audio_io_handle_t input);
@@ -111,21 +109,21 @@ public: 
        // indicates to the audio policy manager that the input stops being used.

        virtual status_t stopInput(audio_io_handle_t input);

        virtual void releaseInput(audio_io_handle_t input);

        virtual void initStreamVolume(AudioSystem::stream_type stream,

        virtual void initStreamVolume(audio_stream_type_t stream,

                                                    int indexMin,

                                                    int indexMax);

        virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream,

        virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,

                                              int index,

                                              audio_devices_t device);

        virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream,

        virtual status_t getStreamVolumeIndex(audio_stream_type_t stream,

                                              int *index,

                                              audio_devices_t device);



        // return the strategy corresponding to a given stream type

        virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream);

        virtual uint32_t getStrategyForStream(audio_stream_type_t stream);



        // return the enabled output devices for the given stream type

        virtual audio_devices_t getDevicesForStream(AudioSystem::stream_type stream);

        virtual audio_devices_t getDevicesForStream(audio_stream_type_t stream);



        virtual audio_io_handle_t getOutputForEffect(const effect_descriptor_t *desc = NULL);

        virtual status_t registerEffect(const effect_descriptor_t *desc,
@@ -136,11 +134,11 @@ public: 
        virtual status_t unregisterEffect(int id);

        virtual status_t setEffectEnabled(int id, bool enabled);



        virtual bool isStreamActive(int stream, uint32_t inPastMs = 0) const;

        virtual bool isStreamActive(audio_stream_type_t stream, uint32_t inPastMs = 0) const;

        // return whether a stream is playing remotely, override to change the definition of

        //   local/remote playback, used for instance by notification manager to not make

        //   media players lose audio focus when not playing locally

        virtual bool isStreamActiveRemotely(int stream, uint32_t inPastMs = 0) const;

        virtual bool isStreamActiveRemotely(audio_stream_type_t stream, uint32_t inPastMs = 0) const;

        virtual bool isSourceActive(audio_source_t source) const;



        virtual status_t dump(int fd);
@@ -254,14 +252,14 @@ protected: 
            status_t    dump(int fd);



            audio_devices_t device() const;

            void changeRefCount(AudioSystem::stream_type stream, int delta);

            void changeRefCount(audio_stream_type_t stream, int delta);



            bool isDuplicated() const { return (mOutput1 != NULL && mOutput2 != NULL); }

            audio_devices_t supportedDevices();

            uint32_t latency();

            bool sharesHwModuleWith(const AudioOutputDescriptor *outputDesc);

            bool isActive(uint32_t inPastMs = 0) const;

            bool isStreamActive(AudioSystem::stream_type stream,

            bool isStreamActive(audio_stream_type_t stream,

                                uint32_t inPastMs = 0,

                                nsecs_t sysTime = 0) const;

            bool isStrategyActive(routing_strategy strategy,
@@ -275,12 +273,12 @@ protected: 
            uint32_t mLatency;                  //

            audio_output_flags_t mFlags;   //

            audio_devices_t mDevice;                   // current device this output is routed to

            uint32_t mRefCount[AudioSystem::NUM_STREAM_TYPES]; // number of streams of each type using this output

            nsecs_t mStopTime[AudioSystem::NUM_STREAM_TYPES];

            uint32_t mRefCount[AUDIO_STREAM_CNT]; // number of streams of each type using this output

            nsecs_t mStopTime[AUDIO_STREAM_CNT];

            AudioOutputDescriptor *mOutput1;    // used by duplicated outputs: first output

            AudioOutputDescriptor *mOutput2;    // used by duplicated outputs: second output

            float mCurVolume[AudioSystem::NUM_STREAM_TYPES];   // current stream volume

            int mMuteCount[AudioSystem::NUM_STREAM_TYPES];     // mute request counter

            float mCurVolume[AUDIO_STREAM_CNT];   // current stream volume

            int mMuteCount[AUDIO_STREAM_CNT];     // mute request counter

            const IOProfile *mProfile;          // I/O profile this output derives from

            bool mStrategyMutedByDevice[NUM_STRATEGIES]; // strategies muted because of incompatible

                                                // device selection. See checkDeviceMuteStrategies()
@@ -301,7 +299,7 @@ protected: 
            audio_channel_mask_t mChannelMask;             //

            audio_devices_t mDevice;                    // current device this input is routed to

            uint32_t mRefCount;                         // number of AudioRecord clients using this output

            int      mInputSource;                      // input source selected by application (mediarecorder.h)

            audio_source_t mInputSource;                // input source selected by application (mediarecorder.h)

            const IOProfile *mProfile;                  // I/O profile this output derives from

        };
@@ -339,7 +337,7 @@ protected: 
        void addOutput(audio_io_handle_t id, AudioOutputDescriptor *outputDesc);



        // return the strategy corresponding to a given stream type

        static routing_strategy getStrategy(AudioSystem::stream_type stream);

        static routing_strategy getStrategy(audio_stream_type_t stream);



        // return appropriate device for streams handled by the specified strategy according to current

        // phone state, connected devices...
@@ -363,7 +361,7 @@ protected: 
                             int delayMs = 0);



        // select input device corresponding to requested audio source

        virtual audio_devices_t getDeviceForInputSource(int inputSource);

        virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource);



        // return io handle of active input or 0 if no input is active

        //    Only considers inputs from physical devices (e.g. main mic, headset mic) when
@@ -375,10 +373,12 @@ protected: 


        // compute the actual volume for a given stream according to the requested index and a particular

        // device

        virtual float computeVolume(int stream, int index, audio_io_handle_t output, audio_devices_t device);

        virtual float computeVolume(audio_stream_type_t stream, int index,

                                    audio_io_handle_t output, audio_devices_t device);



        // check that volume change is permitted, compute and send new volume to audio hardware

        status_t checkAndSetVolume(int stream, int index, audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false);

        status_t checkAndSetVolume(audio_stream_type_t stream, int index, audio_io_handle_t output,

                                   audio_devices_t device, int delayMs = 0, bool force = false);



        // apply all stream volumes to the specified output and device

        void applyStreamVolumes(audio_io_handle_t output, audio_devices_t device, int delayMs = 0, bool force = false);
@@ -391,7 +391,7 @@ protected: 
                             audio_devices_t device = (audio_devices_t)0);



        // Mute or unmute the stream on the specified output

        void setStreamMute(int stream,

        void setStreamMute(audio_stream_type_t stream,

                           bool on,

                           audio_io_handle_t output,

                           int delayMs = 0,
@@ -399,7 +399,7 @@ protected: 


        // handle special cases for sonification strategy while in call: mute streams or replace by

        // a special tone in the device used for communication

        void handleIncallSonification(int stream, bool starting, bool stateChange);

        void handleIncallSonification(audio_stream_type_t stream, bool starting, bool stateChange);



        // true if device is in a telephony or VoIP call

        virtual bool isInCall();
@@ -414,7 +414,7 @@ protected: 
        // returns its handle if any.

        // transfers the audio tracks and effects from one output thread to another accordingly.

        status_t checkOutputsForDevice(audio_devices_t device,

                                       AudioSystem::device_connection_state state,

                                       audio_policy_dev_state_t state,

                                       SortedVector<audio_io_handle_t>& outputs,

                                       const String8 paramStr);
@@ -480,7 +480,7 @@ protected: 
                                            uint32_t delayMs);



        audio_io_handle_t selectOutput(const SortedVector<audio_io_handle_t>& outputs,

                                       AudioSystem::output_flags flags);

                                       audio_output_flags_t flags);

        IOProfile *getInputProfile(audio_devices_t device,

                                   uint32_t samplingRate,

                                   audio_format_t format,
@@ -530,9 +530,9 @@ protected: 
                                                // without AUDIO_DEVICE_BIT_IN to allow direct bit

                                                // field comparisons

        int mPhoneState;                                                    // current phone state

        AudioSystem::forced_config mForceUse[AudioSystem::NUM_FORCE_USE];   // current forced use configuration

        audio_policy_forced_cfg_t mForceUse[AUDIO_POLICY_FORCE_USE_CNT];   // current forced use configuration



        StreamDescriptor mStreams[AudioSystem::NUM_STREAM_TYPES];           // stream descriptors for volume control

        StreamDescriptor mStreams[AUDIO_STREAM_CNT];           // stream descriptors for volume control

        String8 mA2dpDeviceAddress;                                         // A2DP device MAC address

        String8 mScoDeviceAddress;                                          // SCO device MAC address

        String8 mUsbCardAndDevice; // USB audio ALSA card and device numbers:
@@ -580,7 +580,7 @@ private: 
                int indexInUi);

        // updates device caching and output for streams that can influence the

        //    routing of notifications

        void handleNotificationRoutingForStream(AudioSystem::stream_type stream);

        void handleNotificationRoutingForStream(audio_stream_type_t stream);

        static bool isVirtualInputDevice(audio_devices_t device);

};