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

Commit da3529b4 authored by Eric Laurent's avatar Eric Laurent
Browse files

Create base class for audio policy manager. 

First implementations of audio policy manager in Eclair branch have shown that most code is common to all platforms.
Creating AudioPolicyManagerBase base class will improve code maintainability and readability.

Audio policy manager code for platforms using generic audio previously in AudioPolicyManagerGeneric is replaced by AudioPolicyManagerBase.
Audio policy manager test code previously in AudioPolicyManagerGeneric is moved to AudioPolicyManagerBase.

Also added a wake lock for delayed commands in AudioPolicyService.
parent 6c3067a0

libs/audioflinger/Android.mk

+5 −6
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ include $(BUILD_STATIC_LIBRARY) 
include $(CLEAR_VARS)



LOCAL_SRC_FILES:=               \

    AudioPolicyManagerGeneric.cpp

    AudioPolicyManagerBase.cpp



LOCAL_SHARED_LIBRARIES := \

    libcutils \
@@ -60,7 +60,7 @@ else 
 LOCAL_SHARED_LIBRARIES += libdl

endif



LOCAL_MODULE:= libaudiopolicygeneric

LOCAL_MODULE:= libaudiopolicybase



ifeq ($(BOARD_HAVE_BLUETOOTH),true)

  LOCAL_CFLAGS += -DWITH_A2DP
@@ -70,7 +70,7 @@ ifeq ($(AUDIO_POLICY_TEST),true) 
  LOCAL_CFLAGS += -DAUDIO_POLICY_TEST

endif



include $(BUILD_SHARED_LIBRARY)

include $(BUILD_STATIC_LIBRARY)



include $(CLEAR_VARS)
@@ -87,11 +87,10 @@ LOCAL_SHARED_LIBRARIES := \ 
    libutils \

	libbinder \

    libmedia \

    libhardware_legacy \

    libaudiopolicygeneric

    libhardware_legacy



ifeq ($(strip $(BOARD_USES_GENERIC_AUDIO)),true)

  LOCAL_STATIC_LIBRARIES += libaudiointerface

  LOCAL_STATIC_LIBRARIES += libaudiointerface libaudiopolicybase

  LOCAL_CFLAGS += -DGENERIC_AUDIO

else

  LOCAL_SHARED_LIBRARIES += libaudio libaudiopolicy

libs/audioflinger/AudioPolicyManagerGeneric.h

deleted100644 → 0
+0 −196
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */





#include <stdint.h>

#include <sys/types.h>



#include <utils/Errors.h>

#include <utils/KeyedVector.h>

#include <hardware_legacy/AudioPolicyInterface.h>

#include <utils/threads.h>





namespace android {



// ----------------------------------------------------------------------------



#define MAX_DEVICE_ADDRESS_LEN 20

#define NUM_TEST_OUTPUTS 5



class AudioPolicyManagerGeneric: public AudioPolicyInterface

#ifdef AUDIO_POLICY_TEST

    , public Thread

#endif //AUDIO_POLICY_TEST

{



public:

                AudioPolicyManagerGeneric(AudioPolicyClientInterface *clientInterface);

        virtual ~AudioPolicyManagerGeneric();



        // AudioPolicyInterface

        virtual status_t setDeviceConnectionState(AudioSystem::audio_devices device,

                                                          AudioSystem::device_connection_state state,

                                                          const char *device_address);

        virtual AudioSystem::device_connection_state getDeviceConnectionState(AudioSystem::audio_devices device,

                                                                              const char *device_address);

        virtual void setPhoneState(int state);

        virtual void setRingerMode(uint32_t mode, uint32_t mask);

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

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

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

        virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream,

                                            uint32_t samplingRate,

                                            uint32_t format,

                                            uint32_t channels,

                                            AudioSystem::output_flags flags);

        virtual status_t startOutput(audio_io_handle_t output, AudioSystem::stream_type stream);

        virtual status_t stopOutput(audio_io_handle_t output, AudioSystem::stream_type stream);

        virtual void releaseOutput(audio_io_handle_t output);

        virtual audio_io_handle_t getInput(int inputSource,

                                            uint32_t samplingRate,

                                            uint32_t format,

                                            uint32_t channels,

                                            AudioSystem::audio_in_acoustics acoustics);

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

        virtual status_t startInput(audio_io_handle_t input);

        // 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,

                                                    int indexMin,

                                                    int indexMax);

        virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index);

        virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int *index);



        virtual status_t dump(int fd);



private:



        enum routing_strategy {

            STRATEGY_MEDIA,

            STRATEGY_PHONE,

            STRATEGY_SONIFICATION,

            STRATEGY_DTMF,

            NUM_STRATEGIES

        };



        // descriptor for audio outputs. Used to maintain current configuration of each opened audio output

        // and keep track of the usage of this output by each audio stream type.

        class AudioOutputDescriptor

        {

        public:

            AudioOutputDescriptor();



            status_t    dump(int fd);



            uint32_t device();

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

            bool isUsedByStream(AudioSystem::stream_type stream) { return mRefCount[stream] > 0 ? true : false; }

            uint32_t refCount();



            uint32_t mSamplingRate;             //

            uint32_t mFormat;                   //

            uint32_t mChannels;                 // output configuration

            uint32_t mLatency;                  //

            AudioSystem::output_flags mFlags;   //

            uint32_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

        };



        // descriptor for audio inputs. Used to maintain current configuration of each opened audio input

        // and keep track of the usage of this input.

        class AudioInputDescriptor

        {

        public:

            AudioInputDescriptor();



            status_t    dump(int fd);



            uint32_t mSamplingRate;                     //

            uint32_t mFormat;                           // input configuration

            uint32_t mChannels;                         //

            AudioSystem::audio_in_acoustics mAcoustics; //

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

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

        };



        // stream descriptor used for volume control

        class StreamDescriptor

        {

        public:

            StreamDescriptor()

            :   mIndexMin(0), mIndexMax(1), mIndexCur(1), mMuteCount(0), mCanBeMuted(true) {}



            void dump(char* buffer, size_t size);



            int mIndexMin;      // min volume index

            int mIndexMax;      // max volume index

            int mIndexCur;      // current volume index

            int mMuteCount;     // mute request counter

            bool mCanBeMuted;   // true is the stream can be muted

        };



        // return the strategy corresponding to a given stream type

        static routing_strategy getStrategy(AudioSystem::stream_type stream);

        // return the output handle of an output routed to the specified device, 0 if no output

        // is routed to the device

        float computeVolume(int stream, int index, uint32_t device);

        // Mute or unmute the stream on the specified output

        void setStreamMute(int stream, bool on, audio_io_handle_t output);

        // 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);





#ifdef AUDIO_POLICY_TEST

        virtual     bool        threadLoop();

                    void        exit();

        int testOutputIndex(audio_io_handle_t output);

#endif //AUDIO_POLICY_TEST





        AudioPolicyClientInterface *mpClientInterface;  // audio policy client interface

        audio_io_handle_t mHardwareOutput;              // hardware output handler



        KeyedVector<audio_io_handle_t, AudioOutputDescriptor *> mOutputs;   // list ot output descritors

        KeyedVector<audio_io_handle_t, AudioInputDescriptor *> mInputs;     // list of input descriptors

        uint32_t mAvailableOutputDevices;                                   // bit field of all available output devices

        uint32_t mAvailableInputDevices;                                    // bit field of all available input devices

        int mPhoneState;                                                    // current phone state

        uint32_t                 mRingerMode;                               // current ringer mode

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



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



#ifdef AUDIO_POLICY_TEST

        Mutex   mLock;

        Condition mWaitWorkCV;



        int             mCurOutput;

        bool            mDirectOutput;

        audio_io_handle_t mTestOutputs[NUM_TEST_OUTPUTS];

        int             mTestInput;

        uint32_t        mTestDevice;

        uint32_t        mTestSamplingRate;

        uint32_t        mTestFormat;

        uint32_t        mTestChannels;

        uint32_t        mTestLatencyMs;

#endif //AUDIO_POLICY_TEST



};



};

libs/audioflinger/AudioPolicyService.cpp

+29 −16
Original line number Diff line number Diff line
@@ -30,9 +30,10 @@ 
#include <utils/String16.h>

#include <utils/threads.h>

#include "AudioPolicyService.h"

#include "AudioPolicyManagerGeneric.h"

#include <hardware_legacy/AudioPolicyManagerBase.h>

#include <cutils/properties.h>

#include <dlfcn.h>

#include <hardware_legacy/power.h>



// ----------------------------------------------------------------------------

// the sim build doesn't have gettid
@@ -43,6 +44,7 @@ 


namespace android {





static const char *kDeadlockedString = "AudioPolicyService may be deadlocked\n";

static const char *kCmdDeadlockedString = "AudioPolicyService command thread may be deadlocked\n";
@@ -67,18 +69,18 @@ AudioPolicyService::AudioPolicyService() 
    char value[PROPERTY_VALUE_MAX];



    // start tone playback thread

    mTonePlaybackThread = new AudioCommandThread();

    mTonePlaybackThread = new AudioCommandThread(String8(""));

    // start audio commands thread

    mAudioCommandThread = new AudioCommandThread();

    mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread"));



#if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST)

    mpPolicyManager = new AudioPolicyManagerGeneric(this);

    mpPolicyManager = new AudioPolicyManagerBase(this);

    LOGV("build for GENERIC_AUDIO - using generic audio policy");

#else

    // if running in emulation - use the emulator driver

    if (property_get("ro.kernel.qemu", value, 0)) {

        LOGV("Running in emulation - using generic audio policy");

        mpPolicyManager = new AudioPolicyManagerGeneric(this);

        mpPolicyManager = new AudioPolicyManagerBase(this);

    }

    else {

        LOGV("Using hardware specific audio policy");
@@ -556,8 +558,8 @@ status_t AudioPolicyService::setVoiceVolume(float volume, int delayMs) 


// -----------  AudioPolicyService::AudioCommandThread implementation ----------



AudioPolicyService::AudioCommandThread::AudioCommandThread()

    :   Thread(false)

AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name)

    : Thread(false), mName(name)

{

    mpToneGenerator = NULL;

}
@@ -565,18 +567,20 @@ AudioPolicyService::AudioCommandThread::AudioCommandThread() 


AudioPolicyService::AudioCommandThread::~AudioCommandThread()

{

    if (mName != "" && !mAudioCommands.isEmpty()) {

        release_wake_lock(mName.string());

    }

    mAudioCommands.clear();

    if (mpToneGenerator != NULL) delete mpToneGenerator;

}



void AudioPolicyService::AudioCommandThread::onFirstRef()

{

    const size_t SIZE = 256;

    char buffer[SIZE];



    snprintf(buffer, SIZE, "AudioCommandThread");



    run(buffer, ANDROID_PRIORITY_AUDIO);

    if (mName != "") {

        run(mName.string(), ANDROID_PRIORITY_AUDIO);

    } else {

        run("AudioCommandThread", ANDROID_PRIORITY_AUDIO);

    }

}



bool AudioPolicyService::AudioCommandThread::threadLoop()
@@ -657,6 +661,10 @@ bool AudioPolicyService::AudioCommandThread::threadLoop() 
                break;

            }

        }

        // release delayed commands wake lock

        if (mName != "" && mAudioCommands.isEmpty()) {

            release_wake_lock(mName.string());

        }

        LOGV("AudioCommandThread() going to sleep");

        mWaitWorkCV.waitRelative(mLock, waitTime);

        LOGV("AudioCommandThread() waking up");
@@ -815,6 +823,11 @@ void AudioPolicyService::AudioCommandThread::insertCommand_l(AudioCommand *comma 


    command->mTime = systemTime() + milliseconds(delayMs);



    // acquire wake lock to make sure delayed commands are processed

    if (mName != "" && mAudioCommands.isEmpty()) {

        acquire_wake_lock(PARTIAL_WAKE_LOCK, mName.string());

    }



    // check same pending commands with later time stamps and eliminate them

    for (i = mAudioCommands.size()-1; i >= 0; i--) {

        AudioCommand *command2 = mAudioCommands[i];
@@ -883,7 +896,7 @@ void AudioPolicyService::AudioCommandThread::insertCommand_l(AudioCommand *comma 
    removedCommands.clear();



    // insert command at the right place according to its time stamp

    LOGV("inserting command: %d at index %ld, num commands %d", command->mCommand, i+1, mAudioCommands.size());

    LOGV("inserting command: %d at index %d, num commands %d", command->mCommand, (int)i+1, mAudioCommands.size());

    mAudioCommands.insertAt(command, i + 1);

}

libs/audioflinger/AudioPolicyService.h

+3 −2
Original line number Diff line number Diff line
@@ -132,7 +132,7 @@ private: 
            SET_VOICE_VOLUME

        };



        AudioCommandThread ();

        AudioCommandThread (String8 name);

        virtual             ~AudioCommandThread();



                    status_t    dump(int fd);
@@ -195,7 +195,8 @@ private: 
        Condition mWaitWorkCV;

        Vector <AudioCommand *> mAudioCommands; // list of pending commands

        ToneGenerator *mpToneGenerator;     // the tone generator

        AudioCommand mLastCommand;

        AudioCommand mLastCommand;          // last processed command (used by dump)

        String8 mName;                      // string used by wake lock fo delayed commands

    };



    // Internal dump utilities.