說明：在下文中AudioTrack被簡寫為AT，AudioFlinger被簡寫為AF，AudioPolicyService被簡寫為AP。

注意：要了解AudioTrack Java API的具體資訊，需要仔細閱讀Android API中的相關文件。閱讀API文件，是一個能快速掌握相關知識的好方法。

//① 根據音訊資料的特性來確定所要分配的緩衝區的最小size

int bufsize =

          AudioTrack.getMinBufferSize(8000,//取樣率：每秒8K個點                     

　　      AudioFormat.CHANNEL_CONFIGURATION_STEREO,//聲道數：雙聲道           

        AudioFormat.ENCODING_PCM_16BIT//取樣精度：一個取樣點16位元，相當於2個位元組

);

//② 建立AudioTrack

AudioTrack trackplayer = new AudioTrack(

                 AudioManager.STREAM_MUSIC,//音訊流型別

                 8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,

　　                 AudioFormat.ENCODING_PCM_16BIT, bufsize,

                 AudioTrack.MODE_STREAM//資料載入模式);

  //③ 開始播放

trackplayer.play() ;

......

//④ 呼叫write寫資料

trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中寫資料

......

 //⑤ 停止播放和釋放資源

trackplayer.stop();//停止播放

trackplayer.release();//釋放底層資源

注意：如果採用STATIC模式，須先呼叫write寫資料，然後再呼叫play。

注意：上面這些型別的劃分和音訊資料本身並沒有關係。例如MUSIC和RING型別都可以是某首MP3歌曲。另外，聲音流型別的選擇沒有固定的標準，例如，鈴聲預覽中的鈴聲可以設定為MUSIC型別。

//注意這些引數的值。想象我們正在一步步的Trace，這些引數都會派上用場

AudioTrack.getMinBufferSize(8000,//每秒8K個點                              

　　      AudioFormat.CHANNEL_CONFIGURATION_STEREO,//雙聲道                  

        AudioFormat.ENCODING_PCM_16BIT);

static public int getMinBufferSize(intsampleRateInHz, int channelConfig,  

                                  intaudioFormat) {

       int channelCount = 0;

       switch(channelConfig) {

       case AudioFormat.CHANNEL_OUT_MONO:

        caseAudioFormat.CHANNEL_CONFIGURATION_MONO:

           channelCount = 1;

           break;

       case AudioFormat.CHANNEL_OUT_STEREO:

       case AudioFormat.CHANNEL_CONFIGURATION_STEREO:

           channelCount = 2;//目前最多支援雙聲道

           break;

        default:

           return AudioTrack.ERROR_BAD_VALUE;

        }

        //目前只支援PCM8和PCM16精度的音訊資料   

        if((audioFormat != AudioFormat.ENCODING_PCM_16BIT)

           && (audioFormat != AudioFormat.ENCODING_PCM_8BIT)) {

           return AudioTrack.ERROR_BAD_VALUE;

        }

      //對取樣頻率也有要求，太低或太高都不行。

        if( (sampleRateInHz < 4000) || (sampleRateInHz > 48000) )

            return AudioTrack.ERROR_BAD_VALUE;

       /*

        呼叫Native函式，先想想為什麼，如果是簡單計算，那麼Java層做不到嗎？

        原來，還需要確認硬體是否支援這些引數，當然得進入Native層查詢了

        */

       int size = native_get_min_buff_size(sampleRateInHz,         

                 channelCount,audioFormat);                       

        if((size == -1) || (size == 0)) {

             return AudioTrack.ERROR;

        }

       else {

           return size;

        }

}

說明：HAL物件的具體實現和硬體廠商有關係，如果沒有特殊說明，我們則把硬體和HAL作為一種東西討論。

/*

注意我們傳入的引數是：

sampleRateInHertz = 8000，nbChannels = 2

audioFormat = AudioFormat.ENCODING_PCM_16BIT

*/

static jintandroid_media_AudioTrack_get_min_buff_size(                    

                 JNIEnv*env,  jobject thiz,

                 jintsampleRateInHertz, jint nbChannels, jint audioFormat)

{

    intafSamplingRate;

    intafFrameCount;

    uint32_t afLatency;

     /*

        下面這些呼叫涉及了AudioSystem，這個和AudioPolicy有關係。這裡僅把它們看成是

資訊查詢即可

    */

   //查詢取樣率，一般返回的是所支援的最高取樣率，例如44100

    if(AudioSystem::getOutputSamplingRate(&afSamplingRate) != NO_ERROR) {

       return -1;

}

     //① 查詢硬體內部緩衝的大小，以Frame為單位。什麼是Frame？

    if(AudioSystem::getOutputFrameCount(&afFrameCount) != NO_ERROR) {

       return -1;

    }

    //查詢硬體的延時時間

    if(AudioSystem::getOutputLatency(&afLatency) != NO_ERROR) {

       return -1;

}

......

說明：Frame是一個單位，經多方查尋，最終在ALSA的wiki中找到了對它的解釋。Frame直觀上用來描述資料量的多少，例如，一幀等於多少位元組。1單位的Frame等於1個取樣點的位元組數×聲道數（比如PCM16，雙聲道的1個Frame等於2×2=4位元組）。

我們知道，1個取樣點只針對一個聲道，而實際上可能會有一或多個聲道。由於不能用一個獨立的單位來表示全部聲道一次取樣的資料量，也就引出了Frame的概念。Frame的大小，就是一個取樣點的位元組數×聲道數。另外，在目前的音效卡驅動程式中，其內部緩衝區也是採用Frame作為單位來分配和管理的。

   ......

   // minBufCount表示緩衝區的最少個數，它以Frame作為單位

   uint32_t minBufCount = afLatency / ((1000 *afFrameCount)/afSamplingRate);

    if(minBufCount < 2) minBufCount = 2;//至少要兩個緩衝

   //計算最小幀個數

   uint32_tminFrameCount =               

         (afFrameCount*sampleRateInHertz*minBufCount)/afSamplingRate;

  //下面根據最小的FrameCount計算最小的緩衝大小   

   intminBuffSize = minFrameCount //計算方法完全符合我們前面關於Frame的介紹

           * (audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1)

           * nbChannels;

    returnminBuffSize;

}

注意：Java空間的分析包括JNI這一層，因為它們二者的關係最為緊密。

AudioTrack trackplayer = new AudioTrack(

                 AudioManager.STREAM_MUSIC,

                 8000,AudioFormat.CHANNEL_CONFIGURATION_ STEREO,

　　                 AudioFormat.ENCODING_PCM_16BIT,bufsize,

                 AudioTrack.MODE_STREAM);

public AudioTrack(int streamType, intsampleRateInHz, int channelConfig,

                 intaudioFormat,int bufferSizeInBytes, int mode)

                  throws IllegalArgumentException {

        mState= STATE_UNINITIALIZED;

        //檢查引數是否合法

       audioParamCheck(streamType, sampleRateInHz, channelConfig,

                         audioFormat,mode);

       //bufferSizeInBytes是通過getMinBufferSize得到的，所以下面的檢查肯定能通過

       audioBuffSizeCheck(bufferSizeInBytes);

        /*

           呼叫native層的native_setup，構造一個WeakReference傳進去。

           不瞭解Java WeakReference讀者可以上網查一下，很簡單

       */

       int initResult = native_setup(new WeakReference<AudioTrack>(this),

         mStreamType,//這個值是AudioManager.STREAM_MUSIC   

         mSampleRate, //這個值是8000       

        mChannels,   //這個值是2

        mAudioFormat,//這個值是AudioFormat.ENCODING_PCM_16BIT      

         mNativeBufferSizeInBytes,//這個值等於bufferSizeInBytes              

        mDataLoadMode);//DataLoadMode是MODE_STREAM       

         ....

}

static int

android_media_AudioTrack_native_setup(JNIEnv*env, jobject thiz,   

                         jobjectweak_this,jint streamType,        

                         jintsampleRateInHertz, jint channels,   

                         jintaudioFormat, jint buffSizeInBytes,  

                         jintmemoryMode)                 

{

    intafSampleRate;

    intafFrameCount;

    //進行一些資訊查詢

  AudioSystem::getOutputFrameCount(&afFrameCount, streamType)；

  AudioSystem::getOutputSamplingRate(&afSampleRate, streamType)；

  AudioSystem::isOutputChannel(channels)；

   //popCount用於統計一個整數中有多少位為1，有很多經典的演算法

int nbChannels = AudioSystem::popCount(channels);

    //Java層的值和JNI層的值轉換

    if(streamType == javaAudioTrackFields.STREAM_MUSIC)

         atStreamType = AudioSystem::MUSIC;

   intbytesPerSample = audioFormat == javaAudioTrackFields.PCM16 ? 2 : 1;

   intformat = audioFormat == javaAudioTrackFields.PCM16 ?

                  AudioSystem::PCM_16_BIT : AudioSystem::PCM_8_BIT;

    //計算以幀為單位的緩衝大小

    intframeCount = buffSizeInBytes / (nbChannels * bytesPerSample);

     //① AudioTrackJniStorage物件，它儲存了一些資訊，後面將詳細分析

   AudioTrackJniStorage* lpJniStorage = new AudioTrackJniStorage();

      ......

     //②建立Native層的AudioTrack物件

   AudioTrack* lpTrack = new AudioTrack();

       if(memoryMode == javaAudioTrackFields.MODE_STREAM) {

       //③STREAM模式

      lpTrack->set(

           atStreamType,//指定流型別

           sampleRateInHertz,

           format,// 取樣點的精度，一般為PCM16或者PCM8

           channels,

           frameCount,

           0,// flags

           audioCallback, //該回撥函式定義在android_media_AudioTrack.cpp中   

        &(lpJniStorage->mCallbackData),

           0,

           0,// 共享記憶體,STREAM模式下為空。實際使用的共享記憶體由AF建立

           true);//內部執行緒可以呼叫JNI函式，還記得“zygote偷樑換柱”那一節嗎？

         } else if (memoryMode == javaAudioTrackFields.MODE_STATIC) {

          //如果是static模式，需要先建立共享記憶體

         lpJniStorage->allocSharedMem(buffSizeInBytes);

         lpTrack->set(

           atStreamType,// stream type

           sampleRateInHertz,

           format,// word length, PCM

           channels,

           frameCount,

           0,// flags

           audioCallback,

          &(lpJniStorage->mCallbackData),

           0,

           lpJniStorage->mMemBase, //STATIC模式下，需要傳遞該共享記憶體

           true);

    }

    ......

    /*

      把JNI層中new出來的AudioTrack物件指標儲存到Java物件的一個變數中，

      這樣就把JNI層的AudioTrack物件和Java層的AudioTrack物件關聯起來了，

     這是Android的常用技法。                        

   */   

     env->SetIntField(thiz,javaAudioTrackFields.nativeTrackInJavaObj,

                     (int)lpTrack);

   // lpJniStorage物件指標也儲存到Java物件中

   env->SetIntField(thiz, javaAudioTrackFields.jniData,(int)lpJniStorage);

  }

注意，這個檔案也可以是裝置檔案。一般來說，mmap函式的具體工作由引數中的那個檔案描述符所對應的驅動或核心模組來完成。

//下面這個結構就是儲存一些變數，沒有什麼特別的作用

struct audiotrack_callback_cookie {

   jclass      audioTrack_class;

   jobject     audioTrack_ref;

 };

class AudioTrackJniStorage {

   public:

       sp<MemoryHeapBase>    mMemHeap;//這兩個Memory很重要

       sp<MemoryBase>         mMemBase;

       audiotrack_callback_cookie mCallbackData;

       int                       mStreamType;

      boolallocSharedMem(int sizeInBytes) {

     /* 

      注意關於MemoryHeapBase和MemoryBase的用法。   

      先new一個MemoryHeapBase，再以它為引數new一個MemoryBase        

    */  

   //① MemoryHeapBase

    mMemHeap = new MemoryHeapBase(sizeInBytes, 0,"AudioTrack Heap Base");

   //②MemoryBase

    mMemBase= new MemoryBase(mMemHeap, 0, sizeInBytes);

    return true;

   }

};

mMemHeap = new MemoryHeapBase(sizeInBytes, 0,"AudioTrack Heap Base");

/*

   MemoryHeapBase有兩個建構函式，我們用的是第一個。

  size表示共享記憶體大小，flags為0，name為"AudioTrackHeap Base"

*/

MemoryHeapBase::MemoryHeapBase(size_t size,uint32_t flags,char const * name)

    :mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),

     mDevice(0), mNeedUnmap(false)

{

    constsize_t pagesize = getpagesize();//獲取系統中的記憶體頁大小，一般為4KB

    size =((size + pagesize-1) & ~(pagesize-1));

   /*   

     建立共享記憶體，ashmem_create_region函式由libcutils提供。

     在真實裝置上將開啟/dev/ashmem裝置得到一個檔案描述符,在模擬器上則建立一個tmp檔案    

  */

   int fd= ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);

  //下面這個函式將通過mmap方式得到記憶體地址，這是Linux的標準做法，有興趣的讀者可以看看

   mapfd(fd,size);

}

MemoryHeapBase::getBaseID() //返回mFd，如果為負數，表明剛才建立共享記憶體失敗了

MemoryHeapBase::getBase()  //共享記憶體起始地址

MemoryHeapBase::getSize() //返回mSize，表示記憶體大小

說明：Android系統通過ashmem建立共享記憶體的原理，和Linux系統中通過開啟檔案建立共享記憶體的原理類似，但ashmem裝置驅動在這方面做了較大的改進，例如增加了引用計數、延時分配實體記憶體的機制（即真正使用的時候才去分配記憶體）等。這些內容，感興趣的讀者還可以自行對其研究。

class MemoryBase : public BnMemory

{

public:

   MemoryBase(const sp<IMemoryHeap>& heap,ssize_t offset, size_tsize);

   virtual sp<IMemoryHeap> getMemory(ssize_t* offset, size_t* size)const;

protected:

    size_tgetSize() const { return mSize; }//返回大小

    ssize_tgetOffset() const { return mOffset;}//返回偏移量

    //返回MemoryHeapBase物件     

    constsp<IMemoryHeap>& getHeap() const { return mHeap;}

};

//MemoryBase的建構函式

MemoryBase::MemoryBase(constsp<IMemoryHeap>& heap,ssize_t offset, size_t size)

    :mSize(size), mOffset(offset), mHeap(heap)

{

}

提醒：這兩個類沒有提供同步物件來保護這塊共享記憶體，所以後續在使用這塊記憶體時，必然需要一個跨程式的同步物件來保護它。這一點，是我在AT中第一次見到它們時想到的，不知道你是否注意過這個問題。

//③ 開始播放

trackplayer.play() ;

//④ 呼叫write寫資料

trackplayer.write(bytes_pkg, 0,bytes_pkg.length) ;//往track中寫資料

static void

android_media_AudioTrack_start(JNIEnv *env,jobject thiz)

{

/*

  從Java的AudioTrack物件中獲取對應Native層的AudioTrack物件指標。

 從int型別直接轉換成指標，不過要是以後ARM平臺支援64位指標了，程式碼就得大修改了。

*/

   AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(

        thiz,javaAudioTrackFields.nativeTrackInJavaObj);

   lpTrack->start(); //很簡單的呼叫

}

static jint android_media_AudioTrack_native_write_short(

                 JNIEnv*env,  jobject thiz,

                 jshortArrayjavaAudioData,jint offsetInShorts,

                 jintsizeInShorts,jint javaAudioFormat) {

        return(android_media_AudioTrack_native_write(

                 env,thiz,(jbyteArray)javaAudioData,offsetInShorts*2,

                 sizeInShorts*2,javaAudioFormat)/ 2);

}

jint writeToTrack(AudioTrack* pTrack, jintaudioFormat,

                 jbyte*data,jint offsetInBytes, jint sizeInBytes) {

   ssize_t written = 0;

  /*

     如果是STATIC模式，sharedBuffer()返回不為空

     如果是STREAM模式，sharedBuffer()返回空

  */

      if (pTrack->sharedBuffer() == 0) {

         //我們的用例是STREAM模式，呼叫write函式寫資料

       written = pTrack->write(data + offsetInBytes, sizeInBytes);

    } else{

        if (audioFormat == javaAudioTrackFields.PCM16){

           if ((size_t)sizeInBytes > pTrack->sharedBuffer()->size()) {

               sizeInBytes = pTrack->sharedBuffer()->size();

           }

        //在STATIC模式下，直接把資料memcpy到共享記憶體，記住在這種模式下要先呼叫write

        //後呼叫play

          memcpy(pTrack->sharedBuffer()->pointer(),

                         data+ offsetInBytes, sizeInBytes);

           written = sizeInBytes;

        }else if (audioFormat == javaAudioTrackFields.PCM8) {

          //如果是PCM8資料，則先轉換成PCM16資料再拷貝

           ......

    }

    returnwritten;

}

static voidandroid_media_AudioTrack_native_release(JNIEnv *env,  jobject thiz) {

    //呼叫android_media_AudioTrack_native_finalize真正釋放資源

   android_media_AudioTrack_native_finalize(env, thiz);

    //之前儲存在Java物件中的指標變數此時都要設定為零

   env->SetIntField(thiz, javaAudioTrackFields.nativeTrackInJavaObj, 0);

   env->SetIntField(thiz, javaAudioTrackFields.jniData, 0);

}

static voidandroid_media_AudioTrack_native_finalize(JNIEnv *env, jobject thiz) {

   AudioTrack *lpTrack = (AudioTrack *)env->GetIntField(

                           thiz, javaAudioTrackFields.nativeTrackInJavaObj);

    if(lpTrack) {

       lpTrack->stop();//呼叫stop

       delete lpTrack; //呼叫AudioTrack的解構函式

}

......

}

說明：為什麼要總結流程呢？

第一：控制了流程，就把握了系統工作的命脈，這一點至關重要。

第二：有些功能的實現縱跨Java/Native層，橫跨兩個程式，這中間有很多封裝、很多的特殊處理，但是其基本流程是不變的。通過精簡流程，我們才能把注意力集中在關鍵點上。

AudioTrack::AudioTrack()//我們使用無參建構函式

    :mStatus(NO_INIT)

{

  //把狀態初始化成NO_INIT。Android的很多類都採用了這種狀態控制

}

/* 

   還記得我們傳入的引數嗎？

 streamType=STREAM_MUSIC,sampleRate=8000,format=PCM_16

 channels=2，frameCount由計算得來，可以假設一個值，例如1024，不影響分析。

  flags=0,cbf=audiocallback, user為cbf的引數，notificationFrames=0

  因為是流模式，所以sharedBuffer=0。threadCanCallJava 為true

*/

status_t AudioTrack::set(int streamType,uint32_t sampleRate,int format,

       int channels,int frameCount,uint32_t flags,callback_t cbf,void* user,

       int notificationFrames,const sp<IMemory>& sharedBuffer,

        boolthreadCanCallJava)

{

    //前面有一些判斷，都是和AudioSystem有關的，以後再分析

    ......

  /*

     audio_io_handle_t是一個int型別，通過typedef定義，這個值的來歷非常複雜，

涉及AudioFlinger和AudioPolicyService， 後邊的分析試將其解釋清楚。

這個值主要被AudioFlinger使用，用來表示內部的工作執行緒索引號。AudioFlinger會根據

情況建立幾個工作執行緒，下面的AudioSystem::getOutput會根據流型別等其他引數最終選

取一個合適的工作執行緒，並返回它在AF中的索引號。

而AudioTrack一般使用混音執行緒（Mixer Thread）

 */

    audio_io_handle_toutput = AudioSystem::getOutput(

                         (AudioSystem::stream_type)streamType,

                          sampleRate,format, channels,

                         (AudioSystem::output_flags)flags);

   //呼叫creatTrack

   status_t status = createTrack(streamType, sampleRate, format,channelCount,

                                  frameCount,flags, sharedBuffer, output);

//cbf是JNI層傳入的回撥函式audioCallback，如果使用者設定了回撥函式，則啟動一個執行緒

  if (cbf!= 0) {

       mAudioTrackThread = new AudioTrackThread(*this, threadCanCallJava);

   }

   returnNO_ERROR;

}

status_t AudioTrack::createTrack(intstreamType,uint32_t sampleRate,

       int format,int channelCount,int frameCount, uint32_t flags,

       const sp<IMemory>& sharedBuffer, audio_io_handle_t output)

{

   status_tstatus;

  /*

    得到AudioFlinger的Binder代理端BpAudioFlinger。

    關於這部分內容，我們已經很熟悉了，以後的講解會跨過Binder，直接分析Bn端的實現

  */

  constsp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();

 /*

向AudioFinger傳送createTrack請求。注意其中的幾個引數，

在STREAM模式下sharedBuffer為空

    output為AudioSystem::getOutput得到一個值，代表AF中的執行緒索引號

該函式返回IAudioTrack（實際型別是BpAudioTrack）物件，後續AF和AT的互動就是

圍繞IAudioTrack進行的

*/

   sp<IAudioTrack> track = audioFlinger->createTrack(getpid(),

        streamType,sampleRate,format,channelCount,frameCount,

        ((uint16_t)flags) << 16,sharedBuffer,output,&status);

   /*

     在STREAM模式下，沒有在AT端建立共享記憶體，但前面提到了AT和AF的資料互動是

通過共享記憶體完成的，這塊共享記憶體最終由AF的createTrack建立。我們以後分析AF時

再做介紹。下面這個呼叫會取出AF建立的共享記憶體

*/

   sp<IMemory> cblk = track->getCblk();

   mAudioTrack.clear();//sp的clear

    mAudioTrack= track;

   mCblkMemory.clear();

    mCblkMemory= cblk;//cblk是control block的簡寫

  /*

    IMemory的pointer在此處將返回共享記憶體的首地址，型別為void*，

    static_cast直接把這個void*型別轉成audio_track_cblk_t，表明這塊記憶體的首部中存在

     audio_track_cblk_t這個物件

  */

    mCblk= static_cast<audio_track_cblk_t*>(cblk->pointer());

   mCblk->out = 1;//out為1表示輸出，out為0表示輸入

   mFrameCount = mCblk->frameCount;

    if(sharedBuffer == 0) {

       //buffers指向資料空間，它的起始位置是共享記憶體的首部加上audio_track_cblk_t的大小

       mCblk->buffers= (char*)mCblk + sizeof(audio_track_cblk_t);

  } else {

       //STATIC模式下的處理

        mCblk->buffers =sharedBuffer->pointer();

        mCblk->stepUser(mFrameCount);//更新資料位置，後面要分析stepUser的作用

    }

    returnNO_ERROR;

}

struct audio_track_cblk_t

{

       Mutex       lock;

       Condition   cv;//這是兩個同步變數，初始化的時候會設定為支援跨程式共享

  /*

   一塊資料緩衝同時被生產者和消費者使用，最重要的就是維護它的讀寫位置了。

   下面定義的這些變數就和讀寫的位置有關，雖然它們的名字並不是那麼直觀。

   另外，這裡提一個擴充套件問題，讀者可以思考一下：

  volatile支援跨程式嗎？要回答這個問題需要理解volatile、CPU Cache機制和共享記憶體的本質

 */

   volatile    uint32_t    user;   //當前寫位置（即生產者已經寫到什麼位置了）

    volatile    uint32_t   server;  //當前讀位置

 /*

    userBase和serverBase要和user及server結合起來用。

    CB巧妙地通過上面幾個變數把一塊線性緩衝當做環形緩衝來使用，以後將單獨分析這個問題

  */

               uint32_t    userBase;  //

               uint32_t    serverBase;

   void*       buffers; //指向資料緩衝的首地址

   uint32_t    frameCount;//資料緩衝的總大小，以Frame為單位

   uint32_t    loopStart; //設定打點播放（即設定播放的起點和終點）

   uint32_t    loopEnd;

     int         loopCount;//迴圈播放的次數

   volatile    union {

                    uint16_t    volume[2];

                    uint32_t    volumeLR;

                }; //和音量有關係，可以不管它

     uint32_t    sampleRate;//取樣率

    uint32_t    frameSize;//一單位Frame的資料大小

    uint8_t     channels;//聲道數

     uint8_t     flowControlFlag;//控制標誌，見下文分析

    uint8_t     out; // AudioTrack為1，AudioRecord為0

    uint8_t     forceReady;

    uint16_t    bufferTimeoutMs;

     uint16_t    waitTimeMs;

      //下面這幾個函式很重要，後續會詳細介紹它們

    uint32_t    stepUser(uint32_tframeCount);//更新寫位置

    bool        stepServer(uint32_tframeCount);//更新讀位置

    void*       buffer(uint32_toffset) const;//返回可寫空間起始位置

    uint32_t    framesAvailable();//還剩多少空間可寫

    uint32_t    framesAvailable_l();

    uint32_t    framesReady();//是否有可讀資料

}

說明：目前這個引數並不直接和音訊輸入輸出裝置的狀態有關係。它在AT和AF中的作用必須結合具體情況，才能分析。

注意：CB實際是按照環形緩衝來處理資料讀寫的，所以user和server的真實作用還需要結合userBase和serverBase。圖7-4只是一個示意圖。

mCblk =static_cast<audio_track_cblk_t*>(cblk->pointer());

 說明：關於audio_track_cblk_t的使用方式，後文會有詳細分析。

enum event_type {

       EVENT_MORE_DATA = 0, //表示AudioTrack需要更多資料

        EVENT_UNDERRUN = 1,//這是Audio的一個術語，表示Audio硬體處於低負荷狀態

       //AT可以設定打點播放，即設定播放的起點和終點,LOOP_END表示已經到達播放終點

        EVENT_LOOP_END= 2,

   /*

     資料使用警戒通知。該值可通過setMarkerPosition ()設定。

     當資料使用超過這個值時，AT會且僅通知一次，有點像WaterMarker。

      這裡所說的資料使用，是針對消費者AF消費的資料量而言的

   */

       EVENT_MARKER = 3,

    /*

      資料使用進度通知。進度通知值由setPositionUpdatePeriod()設定，

      例如每使用500幀通知一次

    */

       EVENT_NEW_POS = 4,

       EVENT_BUFFER_END = 5   //資料全部被消耗

    };

bool AudioTrack::AudioTrackThread::threadLoop()

{

  //mReceiver就是建立該執行緒的AudioTrack

  returnmReceiver.processAudioBuffer(this);

}

bool AudioTrack::processAudioBuffer(constsp<AudioTrackThread>& thread)

{

    BufferaudioBuffer;

   uint32_t frames;

    size_twrittenSize;

    //處理underun的情況

    if(mActive && (mCblk->framesReady() == 0)) {

        if(mCblk->flowControlFlag == 0) {

           mCbf(EVENT_UNDERRUN, mUserData, 0);//under run 通知

           if (mCblk->server == mCblk->frameCount) {

        /*

             server是讀位置，frameCount是buffer中的資料總和

             當讀位置等於資料總和時，表示資料都已經使用完了

          */

               mCbf(EVENT_BUFFER_END, mUserData, 0);

           }

           mCblk->flowControlFlag = 1;

           if (mSharedBuffer != 0) return false;

        }

    }

    // 迴圈播放通知

    while(mLoopCount > mCblk->loopCount) {

       int loopCount = -1;

       mLoopCount--;

        if(mLoopCount >= 0) loopCount = mLoopCount;

        //一次迴圈播放完畢，loopCount表示還剩多少次

       mCbf(EVENT_LOOP_END, mUserData, (void *)&loopCount);

    }

     if(!mMarkerReached && (mMarkerPosition > 0)) {

        if(mCblk->server >= mMarkerPosition) {

         //如果資料使用超過警戒值，則通知使用者

           mCbf(EVENT_MARKER, mUserData, (void *)&mMarkerPosition);

           //只通知一次，因為該值被設為true

           mMarkerReached = true;

        }

    }

    if(mUpdatePeriod > 0) {

       while (mCblk->server >= mNewPosition) {

       /*

          進度通知，但它不是以時間為基準，而是以幀數為基準的。

          例如設定每500幀通知一次，假設消費者一次就讀了1500幀，那麼這個迴圈會連續通知3次

       */

           mCbf(EVENT_NEW_POS, mUserData, (void *)&mNewPosition);

           mNewPosition += mUpdatePeriod;

        }

    }

    if(mSharedBuffer != 0) {

       frames = 0;

    } else{

       frames = mRemainingFrames;

    }

    do {

       audioBuffer.frameCount = frames;

       //得到一塊可寫的緩衝

       status_t err = obtainBuffer(&audioBuffer, 1);

        ......

       //從使用者那pull資料

       mCbf(EVENT_MORE_DATA, mUserData, &audioBuffer);

       writtenSize = audioBuffer.size;

        ......

        if(writtenSize > reqSize) writtenSize = reqSize;

       //PCM8資料轉PCM16

        .......

       audioBuffer.size = writtenSize;

       audioBuffer.frameCount = writtenSize/mCblk->frameSize;

       frames -= audioBuffer.frameCount;

       releaseBuffer(&audioBuffer);//寫完畢，釋放這塊緩衝

    }

    while(frames);

   　......

    returntrue;

}

static void audioCallback(int event, void* user,void *info) {

    if(event == AudioTrack::EVENT_MORE_DATA) {

         //很好，沒有提供資料，也就是說，雖然AudioTrackThread通知了EVENT_MORE_DATA，

        //但是我們並沒有提供資料給它

       AudioTrack::Buffer* pBuff = (AudioTrack::Buffer*)info;

       pBuff->size = 0;  

     }

    ......

重點強調：帶著問題和思考來分析程式碼相當於“智取”，它比一上來就直接扎入原始碼的“強攻”要高明得多。希望我們能掌握這種思路和方法。

ssize_t AudioTrack::write(const void* buffer,size_t userSize)

{

  if(mSharedBuffer != 0) return INVALID_OPERATION;

    if(ssize_t(userSize) < 0) {

       returnBAD_VALUE;

    }

   ssize_t written = 0;

    constint8_t *src = (const int8_t *)buffer;

    BufferaudioBuffer; // Buffer是一個輔助性的結構

 do {

        //以幀為單位

       audioBuffer.frameCount = userSize/frameSize();

        //obtainBuffer從共享記憶體中得到一塊空閒的資料塊

        status_terr = obtainBuffer(&audioBuffer, -1);

        ......

       size_t toWrite;

        if(mFormat == AudioSystem::PCM_8_BIT &&

                          !(mFlags &AudioSystem::OUTPUT_FLAG_DIRECT)) {

             //PCM8資料轉PCM16

        }else {

           //空閒資料緩衝的大小是audioBuffer.size。

         //地址在audioBuffer.i8中，資料傳遞通過memcpy完成

           toWrite = audioBuffer.size;

           memcpy(audioBuffer.i8, src, toWrite);

           src += toWrite;

        }

       userSize -= toWrite;

       written += toWrite;

       //releaseBuffer更新寫位置，同時會觸發消費者

       releaseBuffer(&audioBuffer);

    }while (userSize);

    returnwritten;

}

status_t AudioTrack::obtainBuffer(Buffer*audioBuffer, int32_t waitCount)

{

    intactive;

   status_t result;

   audio_track_cblk_t* cblk = mCblk;

    ......

   //①呼叫framesAvailable，得到當前可寫的空間大小

   uint32_t framesAvail = cblk->framesAvailable();

    if(framesAvail == 0) {

        ......

        //如果沒有可寫空間，則要等待一段時間

        result= cblk->cv.waitRelative(cblk->lock,milliseconds(waitTimeMs));

          ......

    }

   cblk->waitTimeMs = 0;

    if(framesReq > framesAvail) {

       framesReq = framesAvail;

    }

    //user為可寫空間起始地址

   uint32_t u = cblk->user;

   uint32_tbufferEnd = cblk->userBase + cblk->frameCount;

    if (u+ framesReq > bufferEnd) {

       framesReq = bufferEnd - u;

    }

     ......

    //②呼叫buffer，得到可寫空間的首地址

   audioBuffer->raw = (int8_t *)cblk->buffer(u);

    active= mActive;

    returnactive ? status_t(NO_ERROR) : status_t(STOPPED);

}

void AudioTrack::releaseBuffer(Buffer*audioBuffer)

{

   audio_track_cblk_t* cblk = mCblk;

   cblk->stepUser(audioBuffer->frameCount);// ③呼叫stepUser更新寫位置

}

AudioTrack::~AudioTrack()

{

    if(mStatus == NO_ERROR) {

       stop();//呼叫stop

        if(mAudioTrackThread != 0) {

           //通知AudioTrackThread退出

           mAudioTrackThread->requestExitAndWait();

           mAudioTrackThread.clear();

        }

       mAudioTrack.clear();

     //將殘留在IPCThreadState 傳送緩衝區的資訊傳送出去

        IPCThreadState::self()->flushCommands();

    }

}

void AudioTrack::stop()

{

   sp<AudioTrackThread> t = mAudioTrackThread;

    if (t!= 0) {

       t->mLock.lock();

    }

    if(android_atomic_and(~1, &mActive) == 1) {

       mCblk->cv.signal();

     /*

        mAudioTrack是IAudioTrack型別，其stop的最終處理在AudioFlinger端

      */

       mAudioTrack->stop();

       //清空迴圈播放設定

        setLoop(0, 0, 0);

         mMarkerReached = false;

        if (mSharedBuffer != 0) {

           flush();

        }

        if(t != 0) {

           t->requestExit();//請求退出AudioTrackThread

        }else {

           setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL);

        }

    }

    if (t!= 0) {

        t->mLock.unlock();

    }

}

int main(int argc, char** argv)

{

  sp<ProcessState> proc(ProcessState::self());

   sp<IServiceManager>sm = defaultServiceManager();

    ....

   //很好，AF和APS都駐留在這個程式

    AudioFlinger::instantiate();

    AudioPolicyService::instantiate();

     ....

   ProcessState::self()->startThreadPool();

   IPCThreadState::self()->joinThreadPool();

}

void AudioFlinger::instantiate() {

   defaultServiceManager()->addService( //把AF新增到ServiceManager中

           String16("media.audio_flinger"), new AudioFlinger());

}

AudioFlinger::AudioFlinger(): BnAudioFlinger(),

       mAudioHardware(0), //代表Audio硬體的HAL物件

       mMasterVolume(1.0f),mMasterMute(false), mNextThreadId(0)

{

   mHardwareStatus= AUDIO_HW_IDLE;

   //建立代表Audio硬體的HAL物件

   mAudioHardware = AudioHardwareInterface::create();

   mHardwareStatus = AUDIO_HW_INIT;

    if(mAudioHardware->initCheck() == NO_ERROR) {

     //設定系統初始化的一些值，有一部分通過Audio HAL設定到硬體中

       setMode(AudioSystem::MODE_NORMAL);

       setMasterVolume(1.0f);

       setMasterMute(false);

    }

}

class AudioHardwareInterface

{

public:

   virtual ~AudioHardwareInterface() {}

     //用於檢查硬體是否初始化成功，返回的錯誤碼定義在include/utils/Errors.h

   virtual status_t    initCheck() =0;

    //設定通話音量，範圍從0到1.0

   virtual status_t   setVoiceVolume(float volume) = 0;

    /*

       設定除通話音量外的其他所有音訊流型別的音量，範圍從0到1.0，如果硬體不支援的話，

       這個功能會由軟體層的混音器完成

     */

   virtual status_t   setMasterVolume(float volume) = 0;

    /*

       設定模式，NORMAL的狀態為普通模式，RINGTONE表示來電模式（這時聽到的聲音是來電鈴聲）

      IN_CALL表示通話模式（這時聽到的聲音是手機通話過程中的語音）

     */

   virtual status_t    setMode(intmode) = 0;

    // 和麥克相關

   virtual status_t   setMicMute(bool state) = 0;

   virtual status_t   getMicMute(bool* state) = 0;

    // 設定/獲取配置引數，採用key/value的組織方式

   virtual status_t   setParameters(const String8& keyValuePairs) = 0;

   virtual String8    getParameters(const String8& keys) = 0;

    // 根據傳入的引數得到輸入緩衝的大小，返回0表示其中某個引數的值Audio HAL不支援

     virtualsize_t    getInputBufferSize(uint32_tsampleRate, int format,

                                                int channelCount) = 0;

        /*下面這幾個函式非常重要 */

     /*

         openOutputStream：建立音訊輸出流物件（相當於開啟音訊輸出裝置）

         AF可以往其中write資料，指標型引數將返回該音訊輸出流支援的型別、聲道數、取樣率等

    */

   virtual AudioStreamOut* openOutputStream(

                                uint32_tdevices,

                                int *format=0,

                                uint32_t*channels=0,

                                uint32_t*sampleRate=0,

                                status_t*status=0) = 0;

   //關閉音訊輸出流

    virtual    void       closeOutputStream(AudioStreamOut* out) = 0;

    /* 建立音訊輸入流物件（相當於開啟音訊輸入裝置），AF可以read資料*/

   virtual AudioStreamIn* openInputStream(

                                uint32_tdevices,

                                int *format,

                                uint32_t*channels,

                                uint32_t *sampleRate,

                                status_t*status,

                               AudioSystem::audio_in_acoustics acoustics) = 0;

   virtual    void        closeInputStream(AudioStreamIn* in) =0;

    //關閉音訊輸入流

   virtual status_t dumpState(int fd, const Vector<String16>&args) = 0;

    //靜態create函式，使用設計模式中的工廠模式，具體返回的物件由廠商根據硬體的情況決定

    staticAudioHardwareInterface* create();

    ......

};

說明：AudioHardwareInterface最重要的功能是建立AudioStreamOut 和AudioStreamIn，它們分別代表音訊輸出裝置和音訊輸入裝置。從這個角度說，是AudioHardwareInterface管理著系統中所有的音訊裝置。Android引入的HAL層，大大簡化了應用層的工作，否則不管是使用libasound（AlSA提供的使用者空間庫）還是ioctl來控制音訊裝置，都會非常麻煩。

sp<IAudioTrack> AudioFlinger::createTrack(

       pid_t pid,//AT的pid號

       int streamType,//流型別，用例中是MUSIC型別

       uint32_t sampleRate,//8000 取樣率

       int format,//PCM_16型別

       int channelCount,//2，雙聲道

       int frameCount,//需要建立緩衝的大小，以幀為單位

       uint32_t flags,

       const sp<IMemory>& sharedBuffer,//AT傳入的共享buffer，這裡為空

       int output,//這個值前面提到過，是AF中的工作執行緒索引號

       status_t *status)

{

   sp<PlaybackThread::Track> track;

   sp<TrackHandle> trackHandle;

   sp<Client> client;

    wp<Client>wclient;

   status_t lStatus;

   {

       Mutex::Autolock _l(mLock);

        //output代表索引號，這裡根據索引號找到一個工作執行緒，它是一個PlaybackThread

       PlaybackThread *thread = checkPlaybackThread_l(output);

       //看看這個程式是否已經是AF的Client,AF根據程式pid來標識不同的Client

         wclient = mClients.valueFor(pid);

        if(wclient != NULL) {

       }else {

        //如果還沒有這個Client資訊，則建立一個，並加入到mClients中去

           client = new Client(this, pid);

           mClients.add(pid, client);

        }

      //在找到的工作執行緒物件中建立一個Track,注意它的型別是Track

       track = thread->createTrack_l(client, streamType, sampleRate, format,

               channelCount, frameCount, sharedBuffer, &lStatus);

    }

   /*

    TrackHandle是Track物件的Proxy，它支援Binder通訊，而Track不支援Binder

    TrackHandle所接收的請求最終會由Track處理，這是典型的Proxy模式

   */

   trackHandle= new TrackHandle(track);

   returntrackHandle;

}

AudioFlinger::PlaybackThread *

                 AudioFlinger::checkPlaybackThread_l(intoutput) const

{

  PlaybackThread*thread = NULL;

  //根據output的值找到對應的thread

    if(mPlaybackThreads.indexOfKey(output) >= 0) {

       thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();

    }

    returnthread;

}

// Android的很多程式碼都採用了內部類的方式進行封裝，看習慣就好了

sp<AudioFlinger::PlaybackThread::Track>

     AudioFlinger::PlaybackThread::createTrack_l(

       const sp<AudioFlinger::Client>& client,int streamType,

        uint32_tsampleRate,int format,int channelCount,int frameCount,

       const sp<IMemory>& sharedBuffer,//注意這個引數，從AT中傳入，為0

       status_t *status)

{

   sp<Track> track;

   status_t lStatus;

    {

       Mutex::Autolock _l(mLock);

      //建立Track物件

     track= new Track(this, client, streamType, sampleRate, format,

                      channelCount, frameCount,sharedBuffer);

      //將新建立的Track加入到內部陣列mTracks中

      mTracks.add(track);

}

   lStatus= NO_ERROR;

   returntrack;

}

AudioFlinger::PlaybackThread::Track::Track(const wp<ThreadBase>& thread,

           const sp<Client>& client,int streamType,uint32_t sampleRate,

           int format,int channelCount,int frameCount,

            const sp<IMemory>& sharedBuffer)

:  TrackBase(thread, client, sampleRate, format, channelCount,

    frameCount,0, sharedBuffer),//sharedBuffer仍然為空

   mMute(false), mSharedBuffer(sharedBuffer), mName(-1)

{

   // mCblk!=NULL? 什麼時候建立的呢？只能看基類TrackBase的建構函式了

   if(mCblk != NULL) {

      mVolume[0] = 1.0f;

      mVolume[1] = 1.0f;

      mStreamType = streamType;

      mCblk->frameSize = AudioSystem::isLinearPCM(format) ?

                              channelCount * sizeof(int16_t): sizeof(int8_t);

    }

}

AudioFlinger::ThreadBase::TrackBase::TrackBase(

           const wp<ThreadBase>& thread,const sp<Client>&client,

           uint32_t sampleRate,int format,int channelCount,int frameCount,

           uint32_t flags,const sp<IMemory>& sharedBuffer)

    :   RefBase(), mThread(thread),mClient(client),mCblk(0),

        mFrameCount(0),mState(IDLE),mClientTid(-1),mFormat(format),

       mFlags(flags & ~SYSTEM_FLAGS_MASK)

{

    size_tsize = sizeof(audio_track_cblk_t);//得到CB物件大小

   //計算資料緩衝大小

   size_tbufferSize = frameCount*channelCount*sizeof(int16_t);

   if(sharedBuffer == 0) {

    //還記得圖7-4嗎？共享記憶體最前面一部分是audio_track_cblk_t，後面才是資料空間

      size+= bufferSize;

   }

   //根據size建立一塊共享記憶體。

   mCblkMemory = client->heap()->allocate(size);

   /*

      pointer()返回共享記憶體的首地址， 並強制轉換void*型別為audio_track_cblk_t*型別。

      其實把它強制轉換成任何型別都可以，但是這塊記憶體中會有CB物件嗎？

   */

     mCblk= static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());

    //①下面這句程式碼看起來很獨特。什麼意思？？？

     new(mCblk)audio_track_cblk_t();

     mCblk->frameCount = frameCount;

     mCblk->sampleRate = sampleRate;

     mCblk->channels = (uint8_t)channelCount;

     if (sharedBuffer == 0) {

       //清空資料區

      mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);

      memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));

      // flowControlFlag初始值為1

      mCblk->flowControlFlag = 1;

     }

      ......

}

new(mCblk) audio_track_cblk_t();

重點說明：這個語句就是C++語言中的placement new。其含義是在括號裡指定的記憶體中建立一個物件。我們知道，普通的new只能在堆上建立物件，堆的地址由系統分配。這裡採用placementnew將使得audio_track_cblk_t建立在共享記憶體上，它就自然而然地能被多個程式看見並使用了。關於placementnew較詳細的知識，還請讀者自己搜尋一下。

sp<IAudioTrack> AudioFlinger::createTrack（......）

{

    sp<TrackHandle>trackHandle;

    ......

    track= thread->createTrack_l(client, streamType, sampleRate,

                    format,channelCount,frameCount, sharedBuffer, &lStatus);

   trackHandle= new TrackHandle(track);

   return trackHandle;//① 這個trackHandle物件竟然沒有在AF中儲存！

 }

討論：Android為什麼不直接讓Track從IBinder派生，直接支援Binder通訊呢？關於這個問題，在看到後面的Track家族圖譜後，我們或許就明白了。

擴充思考：關於這個問題的答案，請讀者自己思考並回答。提示，可從Binder和RefBase入手。

class AudioFlinger : public BnAudioFlinger,public IBinder::DeathRecipient

class Client : public RefBase {

   public:

       Client(const sp<AudioFlinger>& audioFlinger, pid_t pid);

       virtual             ~Client();

       const sp<MemoryDealer>&    heap() const;

       pid_t               pid() const {return mPid; }

        sp<AudioFlinger>    audioFlinger() { return mAudioFlinger; }

   private:

                            Client(constClient&);

                            Client&operator = (const Client&);

       sp<AudioFlinger>   mAudioFlinger;

       sp<MemoryDealer>   mMemoryDealer;//記憶體分配器

       pid_t                  mPid;

    };

注意：一個Client程式可以建立多個AudioTrack，這些AudioTrack都屬於一個Client。

說明：大部分常見音訊輸出使用的是MixerThread，後文會對此進行詳細分析。另外，在擴充內容中，也將深入分析DuplicatingThread的實現。

注意：這裡把RecordTrack也統稱為Track。

說明：從圖7-10也能看出，之所以不讓Track繼承Binder框架，是因為Track本身的繼承關係和所承擔的工作已經很複雜了，如再讓它摻合Binder，只會亂上添亂。

AudioFlinger::PlaybackThread *

        AudioFlinger::checkPlaybackThread_l(intoutput) const

{

  PlaybackThread*thread = NULL;

  //根據output的值找到對應的thread

    if(mPlaybackThreads.indexOfKey(output) >= 0) {

       thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();

  }

    returnthread;

}

AudioPolicyService::AudioPolicyService()

    :BnAudioPolicyService() , mpPolicyManager(NULL)

{

    charvalue[PROPERTY_VALUE_MAX];

    // Tone音播放執行緒

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

    // 命令處理執行緒

   mAudioCommandThread = newAudioCommandThread(String8("ApmCommandThread"));

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

    //這裡屬於Generic的情況，所以構造AudioPolicyManagerBase，注意建構函式的引數

   mpPolicyManager = new AudioPolicyManagerBase(this);

#else

......

    //建立和硬體廠商相關的AudioPolicyManager

#endif

    ......

}

AudioPolicyManagerBase::AudioPolicyManagerBase(

           AudioPolicyClientInterface*clientInterface)

        :mPhoneState(AudioSystem::MODE_NORMAL), mRingerMode(0),

           mMusicStopTime(0),mLimitRingtoneVolume(false)

{

    mpClientInterface = clientInterface;

    // 先把不相關的內容去掉

    ......

  /*

     返回來呼叫mpClientInterface的openOutput，實際就是AudioPolicyService。

      注意openOutput函式是在AP的建立過程中呼叫的

  */

   mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                    &outputDesc->mSamplingRate,

                                   &outputDesc->mFormat,

                                   &outputDesc->mChannels,

                                   &outputDesc->mLatency,

                                    outputDesc->mFlags);

    ......

}

audio_io_handle_tAudioPolicyService::openOutput(uint32_t *pDevices,

                                uint32_t*pSamplingRate,

                                uint32_t*pFormat,

                               uint32_t*pChannels,

                                uint32_t*pLatencyMs,

                               AudioSystem::output_flags flags)

{

  sp<IAudioFlinger>af = AudioSystem::get_audio_flinger();

  //下面會呼叫AudioFlinger的openOutput，這個時候AF已經啟動了

   returnaf->openOutput(pDevices, pSamplingRate, (uint32_t *)pFormat,

                          pChannels, pLatencyMs,flags);

}

int AudioFlinger::openOutput(

uint32_t *pDevices,uint32_t*pSamplingRate,uint32_t *pFormat,

       uint32_t*pChannels,uint32_t *pLatencyMs,uint32_t flags)

{

   ......

  Mutex::Autolock _l(mLock);

   //建立Audio HAL的音訊輸出物件，和音訊輸出扯上了關係

   AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices,

                                                            (int *)&format,

                                                            &channels,

                                                            &samplingRate,

                                                            &status);

   mHardwareStatus = AUDIO_HW_IDLE;

    if(output != 0) {

        if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) ||

           (format != AudioSystem::PCM_16_BIT) ||

           (channels != AudioSystem::CHANNEL_OUT_STEREO)) {

           //如果標誌為OUTPUT_FLAG_DIRECT,則建立DirectOutputThread

           thread = new DirectOutputThread(this, output, ++mNextThreadId);

          } else {

         //一般建立的都是MixerThread，注意代表AudioStreamOut物件的output也傳進去了

          thread= new MixerThread(this, output, ++mNextThreadId);

        }

        //把新建立的執行緒加入執行緒組mPlaybackThreads中儲存, mNextThreadId是它的索引號

       mPlaybackThreads.add(mNextThreadId, thread);

       ......

     return mNextThreadId;//返回該執行緒的索引號

    }

    return0;

}

AudioFlinger::MixerThread::MixerThread(

        constsp<AudioFlinger>& audioFlinger,

        AudioStreamOut*output, // AudioStreamOut為音訊輸出裝置的HAL抽象

        intid)

     :  PlaybackThread(audioFlinger, output, id),mAudioMixer(0)

{

   mType = PlaybackThread::MIXER;

  //混音器物件，這個物件比較複雜，它完成多路音訊資料的混合工作

  mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);

}

AudioFlinger::PlaybackThread::PlaybackThread(constsp<AudioFlinger>&

            audioFlinger, AudioStreamOut* output, int id)

        :   ThreadBase(audioFlinger, id),

          mMixBuffer(0),mSuspended(0), mBytesWritten(0),

         mOutput(output), mLastWriteTime(0),mNumWrites(0),

          mNumDelayedWrites(0), mInWrite(false)

{

    //獲取音訊輸出HAL物件的一些資訊，包括硬體中音訊緩衝區的大小（以幀為單位）

    readOutputParameters();

    mMasterVolume= mAudioFlinger->masterVolume();

    mMasterMute= mAudioFlinger->masterMute();

  //設定不同型別音訊流的音量及靜音情況

    for(int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++)

    {

        mStreamTypes[stream].volume=

                     mAudioFlinger->streamVolumeInternal(stream);

        mStreamTypes[stream].mute= mAudioFlinger->streamMute(stream);

    }

  //傳送一個通知訊息給監聽者，這部分內容較簡單，讀者可自行研究

  sendConfigEvent(AudioSystem::OUTPUT_OPENED);

 }

void AudioFlinger::PlaybackThread::onFirstRef()

{

    constsize_t SIZE = 256;

    charbuffer[SIZE];

   snprintf(buffer, SIZE, "Playback Thread %p", this);

   //下面的run就真正建立了執行緒並開始執行threadLoop

   run(buffer, ANDROID_PRIORITY_URGENT_AUDIO);

}

status_tAudioFlinger::PlaybackThread::Track::start()

{

   status_t status = NO_ERROR;

    sp<ThreadBase>thread = mThread.promote();

  //該Thread是用例中的MixerThread

    if(thread != 0) {

        Mutex::Autolock _l(thread->mLock);

       int state = mState;

        if (mState == PAUSED) {

           mState = TrackBase::RESUMING;

          } else {

           mState = TrackBase::ACTIVE;//設定Track的狀態

        }

        PlaybackThread *playbackThread =(PlaybackThread *)thread.get();

        //addTrack_l把這個track加入到mActiveTracks陣列中

       playbackThread->addTrack_l(this);

    returnstatus;

}

status_tAudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)

{

   status_t status = ALREADY_EXISTS;

    //①mRetryCount：設定重試次數，kMaxTrackStartupRetries值為50

   track->mRetryCount = kMaxTrackStartupRetries;

   if(mActiveTracks.indexOf(track) < 0) {

      //②mFillingUpStatus：緩衝狀態

      track->mFillingUpStatus= Track::FS_FILLING;

      //原來是把呼叫start的這個track加入到活躍的Track陣列中了

     mActiveTracks.add(track);

     status = NO_ERROR;

   }

  //廣播一個事件，一定會觸發MixerThread執行緒，通知它有活躍陣列加入，需要開工幹活

   mWaitWorkCV.broadcast();

    return status;

}

說明：我們在介紹大流程的同時也把一些細節問題指出來，希望這些細節問題能激發讀者深入研究的慾望。

bool AudioFlinger::MixerThread::threadLoop()

{

   int16_t* curBuf = mMixBuffer;

   Vector< sp<Track> > tracksToRemove;

   uint32_t mixerStatus = MIXER_IDLE;

    nsecs_tstandbyTime = systemTime();

    ......

    uint32_t sleepTime = idleSleepTime;

    while(!exitPending())

    {

     //① 處理一些請求和通知訊息，如之前在建構函式中發出的OUTPUT_OPEN訊息等

      processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {// scope for mLock

           Mutex::Autolock _l(mLock);

          //檢查配置引數，如有需要則重新設定內部引數值

           if (checkForNewParameters_l()) {

               mixBufferSize = mFrameCount * mFrameSize;

               maxPeriod = seconds(mFrameCount) / mSampleRate * 3;

               ......

           }

          //獲得當前的已啟用track陣列

           const SortedVector< wp<Track> >& activeTracks =mActiveTracks;

             ......

           /*

            ②prepareTracks_l將檢查mActiveTracks陣列，判斷是否有AT的資料需要處理。

               例如有些AudioTrack雖然呼叫了start，但是沒有及時write資料，這時就無須

進行混音工作。我們待會再分析prepareTracks_l函式

          */

           mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);

       }

        //MIXER_TRACKS_READY表示AT已經把資料準備好了

        if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {

           //③ 由混音物件進行混音工作，混音的結果放在curBuf中

           mAudioMixer->process(curBuf);

           sleepTime = 0;//等待時間設定為零，表示需要馬上輸出到Audio HAL

           standbyTime = systemTime() + kStandbyTimeInNsecs;

        }

          .......

        if(sleepTime == 0) {

           ......

          //④ 往Audio HAL的OutputStream中write混音後的資料，這是音訊資料的最終歸宿

           int bytesWritten = (int)mOutput->write(curBuf, mixBufferSize);

           if (bytesWritten < 0) mBytesWritten -= mixBufferSize;

             ......

           mStandby = false;

        }else {

           usleep(sleepTime);

        }

       tracksToRemove.clear();

    }

    if(!mStandby) {

       mOutput->standby();

    }

    returnfalse;

}

uint32_tAudioFlinger::MixerThread::prepareTracks_l(

                         constSortedVector<wp<Track>>& activeTracks,

                         Vector<sp<Track>>*tracksToRemove)

{

   uint32_t mixerStatus = MIXER_IDLE;

    //啟用Track的個數

    size_tcount = activeTracks.size();

    floatmasterVolume = mMasterVolume;

   bool  masterMute = mMasterMute;

  //依次查詢這些Track的情況

   for(size_t i=0 ; i<count ; i++) {

       sp<Track> t = activeTracks[i].promote();

        if(t == 0) continue;

       Track* const track = t.get();

     //怎麼查？通過audio_track_cblk_t物件

       audio_track_cblk_t* cblk = track->cblk();

   /*

      一個混音器可支援32個Track，它內部有一個32元素的陣列，name函式返回的就是Track在

      這個陣列中的索引。混音器每次通過setActiveTrack設定一個活躍Track，

      後續所有操作都會針對當前設定的這個活躍Track

    */

       mAudioMixer->setActiveTrack(track->name());
       

      //下面這個判斷語句決定了什麼情況下Track資料可用

     if (cblk->framesReady() &&(track->isReady() || track->isStopped())

             && !track->isPaused()&& !track->isTerminated())

        {

            ......

           /*

            設定活躍Track的資料提供者為Track本身，因為Track從AudioBufferProvider

            派生。混音器工作時，需從Track得到待混音的資料，也就是AT寫入的資料由混音

            器取出並消費

         */

          mAudioMixer->setBufferProvider(track);

          //設定對應Track的混音標誌

           mAudioMixer->enable(AudioMixer::MIXING);

          ......

           //設定該Track的音量等資訊，這在以後的混音操作中會使用

           mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left);

            mAudioMixer->setParameter(param,AudioMixer::VOLUME1, right);

           mAudioMixer->setParameter(

               AudioMixer::TRACK,

               AudioMixer::FORMAT, track->format());

            ......

            mixerStatus = MIXER_TRACKS_READY;

        }else {//如果不滿足上面的條件，則走else分支

           if (track->isStopped()) {

               track->reset();//reset會清零讀寫位置，表示沒有可讀資料

           }

           //如果處於這三種狀態之一，則加入移除佇列

           if (track->isTerminated() || track->isStopped()

                    || track->isPaused()) {

               tracksToRemove->add(track);

               mAudioMixer->disable(AudioMixer::MIXING);

           } else {

             //不處於上面三種狀態時，表示暫時沒有可讀資料，則重試mRetryCount次

            if (--(track->mRetryCount) <= 0) {

                 tracksToRemove->add(track);

               } else if (mixerStatus != MIXER_TRACKS_READY) {

                    mixerStatus =MIXER_TRACKS_ENABLED;

               }

             //禁止這個Track的混音

               mAudioMixer->disable(AudioMixer::MIXING);

            ......

         }

        }

    }

    //對那些被移除的Track做最後的處理

   ......

    returnmixerStatus;

}

void AudioMixer::process(void* output)

{

   mState.hook(&mState, output);//hook？這是一個函式指標

}

AudioMixer::AudioMixer(size_t frameCount,uint32_t sampleRate)

    :   mActiveTrack(0), mTrackNames(0),mSampleRate(sampleRate)

{

   mState.enabledTracks= 0;

   mState.needsChanged = 0;

   mState.frameCount   = frameCount;//這個值等於音訊輸出物件的緩衝大小

   mState.outputTemp   = 0;

    mState.resampleTemp= 0;

    //hook初始化的時候為process__nop，這個函式什麼都不會做

    mState.hook = process__nop;

    track_t*t = mState.tracks;//track_t是和Track相對應的一個結構

    //最大支援32路混音，也很不錯了

    for(int i=0 ; i<32 ; i++) {

        ......

       t->channelCount = 2;

       t->enabled = 0;

       t->format = 16;

        t->buffer.raw = 0;

       t->bufferProvider = 0; // bufferProvider為這一路Track的資料提供者

       t->hook = 0;//每一個Track也有一個hook函式

        ......

    }

   int             mActiveTrack;

   uint32_t        mTrackNames;

    constuint32_t  mSampleRate;

    state_t         mState

}

struct state_t {

       uint32_t        enabledTracks;

       uint32_t        needsChanged;

       size_t          frameCount;

       mix_t           hook;

       int32_t         *outputTemp;

       int32_t         *resampleTemp;

       int32_t         reserved[2];

  /*

    aligned表示32位元組對齊，由於source insight不認識這個標誌，導致

    state_t不能被解析。在看程式碼時，可以註釋掉後面的attribute，這樣source insight

     就可以識別state_t結構了

 */   

         track_t         tracks[32]; __attribute__((aligned(32)));

    };

mAudioMixer->setBufferProvider(track);

mAudioMixer->enable(AudioMixer::MIXING);//使能混音

status_t AudioMixer::enable(int name)

{

    switch(name) {

       case MIXING: {

           if (mState.tracks[ mActiveTrack ].enabled != 1) {

               mState.tracks[ mActiveTrack ].enabled = 1;

               //注意這個invalidateState呼叫

               invalidateState(1<<mActiveTrack);

           }

        }break;

       default:

           return NAME_NOT_FOUND;

    }

    returnNO_ERROR;

}

void AudioMixer::invalidateState(uint32_t mask)

 {

    if(mask) {

       mState.needsChanged |= mask;

       mState.hook = process__validate;//將hook設定為process_validate

    }

 }

void AudioMixer::process__validate(state_t*state, void* output)

{

   uint32_t changed = state->needsChanged;

   state->needsChanged = 0;

  uint32_t enabled = 0;

   uint32_t disabled = 0;

    ......

    if(countActiveTracks) {

        if(resampling) {

           ......

         //如果需要重取樣，則選擇process__genericResampling

           state->hook = process__genericResampling;

        }else {

           ......

           state->hook = process__genericNoResampling;

           if (all16BitsStereoNoResample && !volumeRamp) {

               if (countActiveTracks == 1) {

             //如果只有一個Track，則使用process__OneTrack16BitsStereoNoResampling

                    state->hook =process__OneTrack16BitsStereoNoResampling;

               }

           }

        }

    }

  state->hook(state, output);

  ......

}

說明：在這個資料消費和之前破解AT的過程中所講的資料生產是對應的，先來提煉AT和AF在生產和消費這兩個環節上與CB互動的流程。

voidAudioMixer::process__OneTrack16BitsStereoNoResampling(

        state_t*state, void* output)

{

   //找到被啟用的Track，此時只能有一個Track，否則就不會選擇這個process函式了

    constint i = 31 - __builtin_clz(state->enabledTracks);

    consttrack_t& t = state->tracks[i];

   AudioBufferProvider::Buffer& b(t.buffer);

    ......

    while(numFrames) {

       b.frameCount = numFrames;

       //BufferProvider就是Track物件，呼叫它的getNextBuffer獲得可讀資料緩衝

       t.bufferProvider->getNextBuffer(&b);

       int16_t const *in = b.i16;

       ......

       size_t outFrames = b.frameCount;

         do {//資料處理，也即是混音

               uint32_t rl = *reinterpret_cast<uint32_t const *>(in);

               in += 2;

               int32_t l = mulRL(1, rl, vrl) >> 12;

               int32_t r = mulRL(0, rl, vrl) >> 12;

              //把資料複製給out緩衝

               *out++ = (r<<16) | (l & 0xFFFF);

           } while (--outFrames);

        }

       numFrames -= b.frameCount;

       //呼叫Track的releaseBuffer釋放緩衝

       t.bufferProvider->releaseBuffer(&b);

    }

}

status_tAudioFlinger::PlaybackThread::Track::getNextBuffer(

                         AudioBufferProvider::Buffer*buffer)

{

     audio_track_cblk_t*cblk = this->cblk();//通過CB物件完成

    uint32_t framesReady;

    //frameCount為AudioOutput音訊輸出物件的緩衝區大小

    uint32_t framesReq = buffer->frameCount;

     ......

     //根據CB的讀寫指標計算有多少幀資料可讀

    framesReady = cblk->framesReady();

     if (LIKELY(framesReady)){

       uint32_t s = cblk->server; //當前讀位置

        //可讀的最大位置，為當前讀位置加上frameCount

         uint32_tbufferEnd = cblk->serverBase + cblk->frameCount;

        //AT可以通過setLooping設定播放的起點和終點，如果有終點的話，需要以loopEnd

       //作為資料緩衝的末尾

       bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd :bufferEnd;

        if(framesReq > framesReady) {

         //如果要求的讀取幀數大於可讀幀數，則只能選擇實際可讀的幀數

           framesReq = framesReady;

        }

       //如果可讀幀數的最後位置超過了AT設定的末端點，則需要重新計算可讀幀數

        if(s + framesReq > bufferEnd) {

           framesReq = bufferEnd - s;

        }

        //根據讀起始位置得到資料緩衝的起始地址，framesReq引數用來做內部檢查，防止出錯

        buffer->raw = getBuffer(s, framesReq);

        if (buffer->raw == 0) goto getNextBuffer_exit;

        buffer->frameCount = framesReq;

       return NO_ERROR;

     }

getNextBuffer_exit:

    buffer->raw = 0;

    buffer->frameCount = 0;

    return NOT_ENOUGH_DATA;

}

void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(

                 AudioBufferProvider::Buffer*buffer)

{

   buffer->raw = 0;

   mFrameCount = buffer->frameCount;//frameCount為getNextBuffer中分配的可讀幀數

   step();//呼叫step函式

   buffer->frameCount = 0;

}

bool AudioFlinger::ThreadBase::TrackBase::step(){

    boolresult;

   audio_track_cblk_t* cblk = this->cblk();

  //呼叫stepServer更新讀位置

    result= cblk->stepServer(mFrameCount);

    if(!result) {

       mFlags |= STEPSERVER_FAILED;

    }

    returnresult;

}

void AudioFlinger::PlaybackThread::Track::stop()

{

   sp<ThreadBase> thread = mThread.promote();

    if(thread != 0) {

       Mutex::Autolock _l(thread->mLock);

       int state = mState;//儲存舊的狀態

        if(mState > STOPPED) {

           mState = STOPPED;//設定新狀態為STOPPED

           PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

           if (playbackThread->mActiveTracks.indexOf(this) < 0) {

               reset();//如果該執行緒的活躍陣列中沒有Track，則重置讀寫位置

            }

       }

       //和APS相關，我們不在這裡討論，它不直接影響AudioFlinger

        if(!isOutputTrack() && (state == ACTIVE || state == RESUMING)) {

           thread->mLock.unlock();

           AudioSystem::stopOutput(thread->id(),

               (AudioSystem::stream_type)mStreamType);

           thread->mLock.lock();

        }

    }

}

if (cblk->framesReady() &&(track->isReady() || track->isStopped())

 && !track->isPaused() &&!track->isTerminated())

說明：在介紹Track和TrackHandle一節中，曾在最後提到了那個野指標問題。相信讀者這時候會知道那個問題的答案了，是嗎？

AudioFlinger::TrackHandle::~TrackHandle() {

   mTrack->destroy();

}

voidAudioFlinger::PlaybackThread::Track::destroy()

{

   sp<Track> keep(this);

    {

       sp<ThreadBase> thread = mThread.promote();

        if(thread != 0) {

            if (!isOutputTrack()) {

              //和AudioSystem相關，以後再分析

               if (mState == ACTIVE || mState == RESUMING) {

                   AudioSystem::stopOutput(thread->id(),

                          (AudioSystem::stream_type)mStreamType);

               }

                AudioSystem::releaseOutput(thread->id());

           }

           Mutex::Autolock _l(thread->mLock);

           PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

          //呼叫回放執行緒物件的destroyTrack_l

           playbackThread->destroyTrack_l(this);

        }

    }

}

voidAudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)

{

   track->mState = TrackBase::TERMINATED;//設定狀態為TERMINATED

    if(mActiveTracks.indexOf(track) < 0) {

       mTracks.remove(track);//如果不在mActiveTracks陣列中，則把它從mTracks中去掉。

       //由PlaybackThread的子類實現，一般就是回收一些資源等工作

       deleteTrackName_l(track->name());

    }

}

AudioFlinger::ThreadBase::TrackBase::~TrackBase()

{

if (mCblk) {

      //placementnew出來的物件需要顯示呼叫的解構函式

       mCblk->~audio_track_cblk_t();

        if(mClient == NULL) {

           delete mCblk;//先呼叫析構，再釋放記憶體，這是placement new的用法

        }

    }

   mCblkMemory.clear();

    if(mClient != NULL) {

       Mutex::Autolock _l(mClient->audioFlinger()->mLock);

       mClient.clear();//如果mClient的強弱引用計數都為0，則會導致該Client被delete

    }

}

說明：其實，要找到TrackHandle是什麼時候被delete，會更有難度。

uint32_t audio_track_cblk_t::framesAvailable()

{

   Mutex::Autolock _l(lock);

    returnframesAvailable_l();//呼叫framesAvailable_l

}

int32_t audio_track_cblk_t::framesAvailable_l()

{

   uint32_t u = this->user; //當前寫者位置，此時也為0

   uint32_t s = this->server; //當前讀者位置，此時為0

    if(out) { //對於音訊輸出，out為1

       uint32_t limit = (s < loopStart) ? s : loopStart;

      //由於不設定播放端點，所以loopStart是初始值INT_MAX， limit=0

       return limit + frameCount - u;

        //返回0+frameCount-0，也就是資料緩衝的全部大小。假設frameCount=1024幀

    }

}

void* audio_track_cblk_t::buffer(uint32_toffset) const

{

   //buffers是資料緩衝的起始位置，offset是計算出來的基於userBase的偏移。

  //通過這種方式巧妙地把資料緩衝當做環形緩衝來處理

   return(int8_t *)this->buffers + (offset - userBase) * this->frameSize;

}

uint32_t audio_track_cblk_t::stepUser(uint32_tframeCount)

{

 /*

   framecount，表示寫了多少幀，前面分配了1024幀，但寫的資料可以比這個少

    假設這一次寫了512幀

  */

   uint32_t u = this->user;//user位置還沒更新，此時u=0；

    u +=frameCount;//u更新了，u=512

    ......

/*

   userBase還是初始值0。可惜只寫了1024的一半,所以userBase加不了。

   但這句話很重要，還記得前面的buffer呼叫嗎？取資料地址的時候用offset-userBase，

   一旦user位置到達緩衝的尾部，則userBase也會更新，這樣offset-userBase的位置就會

   回到緩衝的頭部，從頭到尾這麼反覆迴圈，不就是一個環形緩衝了嗎？非常巧妙！

 */

   if (u>= userBase + this->frameCount) {

       userBase += this->frameCount;

    }

   this->user = u;//喔，user位置也更新為512了，但是useBase還是0

    returnu;

}

uint32_t audio_track_cblk_t::framesReady()

{

   uint32_t u = this->user; //u為512

    uint32_ts = this->server;//還沒讀呢，s為零

    if(out) {

        if(u < loopEnd) {

           return u - s;//loopEnd也是INT_MAX，所以這裡返回512，表示有512幀可讀了

        }else {

           Mutex::Autolock _l(lock);

           if (loopCount >= 0) {

               return (loopEnd - loopStart)*loopCount + u - s;

           } else {

               return UINT_MAX;

           }

        }

    } else{

       return s - u;

    }

}

bool audio_track_cblk_t::stepServer(uint32_tframeCount)

{

   status_t err;

     err = lock.tryLock();

   uint32_t s = this->server;

    s +=frameCount; //讀了512幀了，所以s=512

     ......

   //沒有設定迴圈播放，所以不走這個

    if (s>= loopEnd) {

       s =loopStart;

        if (--loopCount == 0) {

           loopEnd = UINT_MAX;

           loopStart = UINT_MAX;

        }

}

     //和userBase一樣的處理

    if (s>= serverBase + this->frameCount) {

       serverBase += this->frameCount;

    }

   this->server = s; //server為512了

   cv.signal(); //讀者讀完了，觸發一個同步訊號，因為讀者可能在等待可寫的資料緩衝

   lock.unlock();

    returntrue;

}

if (u >= userBase + this->frameCount) {

    //u為1024，userBase為0，frameCount為1024

   userBase += this->frameCount;//好，userBase也為1024了

}

uint32_t audio_track_cblk_t::framesAvailable_l()

{

   uint32_t u = this->user; //1024，寫者上一次寫完了整個1024幀空間

   uint32_t s = this->server;//512，讀者當前讀到的位置

    if(out) {

       uint32_t limit = (s < loopStart) ? s : loopStart;

       return limit + frameCount - u;//返回512

    }

}

return (int8_t *)this->buffers + (offset -userBase) * this->frameSize;

//offset是外界傳入的基於userBase的一個偏移量，它的值是userBase+512，所以

//offset-userBase將得到從頭開始的那段資料空間。真的是一個環形緩衝。

AudioPolicyService::AudioPolicyService()

        :BnAudioPolicyService() ,

//mpPolicyManager是Audio系統中的另一種HAL物件，它的型別是AudioPolicyInterface

        mpPolicyManager(NULL)

{

     char value[PROPERTY_VALUE_MAX];

    //TonePlayback用於播放Tone音，Tone包括按鍵音等

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

   //用於處理控制命令，例如路由切換、音量調節等

   mAudioCommandThread = newAudioCommandThread(String8("ApmCommandThread"));

#if (defined GENERIC_AUDIO) || (definedAUDIO_POLICY_TEST)

    //注意AudioPolicyManagerBase的建構函式，把this傳進去了。

     mpPolicyManager = new AudioPolicyManagerBase(this);

#else

...

   //使用硬體廠商實現的AudioPolicyInterface

    mpPolicyManager= createAudioPolicyManager(this);

#endif

  //根據系統屬性來判斷照相機拍照時是否強制發聲。為了防止偷拍，強制按快門的時候必須發出聲音。

    property_get("ro.camera.sound.forced",value, "0");

    mpPolicyManager->setSystemProperty("ro.camera.sound.forced",value);

}

class AudioPolicyInterface

{

public:

......

     //設定裝置的連線狀態，這些裝置有耳機、藍芽等

    virtualstatus_t setDeviceConnectionState(

                         AudioSystem::audio_devicesdevice,

                        AudioSystem::device_connection_state state,

                         const char *device_address) = 0;

    //設定系統Phone狀態，這些狀態包括通話狀態、來電狀態等

   virtual void setPhoneState(int state) = 0;

    //設定force_use的config策略，例如通話中強制使用揚聲器

   virtualvoid setForceUse(AudioSystem::force_use usage,

                             AudioSystem::forced_config config) = 0;

     /*

        audio_io_handle_t是int型別。這個函式的目的是根據傳入的引數型別

       找到合適的輸出控制程式碼。這個控制程式碼，在目前的Audio系統代表AF中的某個工作執行緒。

       還記得建立AudioTrack的時候傳入的那個output值嗎？它就是通過這個函式得來的。

       關於這個問題，馬上會分析到

    */

   virtualaudio_io_handle_t getOutput(

                 AudioSystem::stream_typestream,

                     uint32_t samplingRate = 0,

                     uint32_t format = AudioSystem::FORMAT_DEFAULT,

                     uint32_t channels = 0,

                     AudioSystem::output_flagsflags =

                 AudioSystem::OUTPUT_FLAG_INDIRECT)= 0;

   //在下面這兩個函式後會介紹。它們的第二個參數列示使用的音訊流型別，

  virtualstatus_t startOutput(audio_io_handle_t output,

                               AudioSystem::stream_type stream) = 0;

  virtual status_t stopOutput(audio_io_handle_toutput,

                            AudioSystem::stream_type stream) = 0;

    ......

    //音量控制：設定不同音訊流的音量級別範圍，例如MUSIC有15個級別的音量

   virtual void initStreamVolume(AudioSystem::stream_type stream,

                                      intindexMin,

                                      intindexMax) = 0;

    //設定某個音訊流型別的音量級，例如覺得music聲音太小時，可以呼叫這個函式提高音量級

   virtualstatus_t setStreamVolumeIndex(AudioSystem::stream_type stream,

                                          int index) = 0;

 }

enum stream_type {

       DEFAULT          =-1,//預設

       VOICE_CALL       = 0,//通話聲

       SYSTEM           = 1,//系統聲，例如開關機提示

       RING             = 2,//來電鈴聲

       MUSIC            = 3,//媒體播放聲

       ALARM            = 4,//鬧鐘等的警告聲

       NOTIFICATION     = 5,//簡訊等的提示聲

       BLUETOOTH_SCO    = 6,//藍芽SCO

       ENFORCED_AUDIBLE = 7,//強制發聲，照相機的快門聲就屬於這個型別

       DTMF             = 8,//DTMF,撥號盤的按鍵聲

       TTS              = 9,//文字轉語音，Text to Speech

       NUM_STREAM_TYPES

    };

enum audio_mode {

       MODE_INVALID = -2,

       MODE_CURRENT = -1,

       MODE_NORMAL = 0, //正常，既不打電話，也沒有來電

       MODE_RINGTONE,//有來電

       MODE_IN_CALL,//通話狀態

       NUM_MODES

};

注意：所謂的裝置切換，是指諸如揚聲器切換到聽筒的情況，而前面常提到的音訊輸出裝置，應該指的是DSP。

注意：藍芽裝置實際上會建立兩條資料通路：SCO和A2DP。A2DP和高質量立體聲有關，且必須由AudioFlinger向它傳送資料。所以“音訊資料需要單獨傳送給藍芽裝置”，這個裝置實際上是指藍芽的A2DP裝置。藍芽技術很複雜，有興趣的讀者可以自行研究。

enum forced_config {

       FORCE_NONE,

       FORCE_SPEAKER,  //強制使用揚聲器

       FORCE_HEADPHONES,

       FORCE_BT_SCO,

       FORCE_BT_A2DP,

       FORCE_WIRED_ACCESSORY,

       FORCE_BT_CAR_DOCK,

       FORCE_BT_DESK_DOCK,

       NUM_FORCE_CONFIG,

       FORCE_DEFAULT = FORCE_NONE

}

    enumforce_use {

       FOR_COMMUNICATION,//通話情況，注意字首，是FOR_XXX

       FOR_MEDIA,//聽音樂等媒體相關的情況

       FOR_RECORD,

       FOR_DOCK,

       NUM_FORCE_USE

}

virtual void setForceUse(AudioSystem::force_useusage,//什麼情況

                          AudioSystem::forced_configconfig //什麼裝置

                         )= 0;

enum audio_devices {

        //output devices

       DEVICE_OUT_EARPIECE = 0x1,  //聽筒

        DEVICE_OUT_SPEAKER = 0x2,   //揚聲器

       DEVICE_OUT_WIRED_HEADSET = 0x4,  //耳機

       DEVICE_OUT_WIRED_HEADPHONE = 0x8, //另外一種耳機

       DEVICE_OUT_BLUETOOTH_SCO = 0x10, //藍芽相關，SCO用於通話的語音傳輸

       DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20,

        DEVICE_OUT_BLUETOOTH_SCO_CARKIT= 0x40,

       DEVICE_OUT_BLUETOOTH_A2DP = 0x80, //藍芽相關，A2DP用於立體聲傳輸

       DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,

       DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,

       DEVICE_OUT_AUX_DIGITAL = 0x400,

        DEVICE_OUT_DEFAULT= 0x8000,

       ......

}

說明：實際上很多硬體廠商實現的AudioPolicyInterface，基本上是直接使用這個AudioPolicyManagerBase。

AudioPolicyManagerBase::AudioPolicyManagerBase(

                          AudioPolicyClientInterface*clientInterface)

                         :mPhoneState(AudioSystem::MODE_NORMAL),mRingerMode(0),

                          mMusicStopTime(0),mLimitRingtoneVolume(false)

{

   //APS實現了AudioPolicyClientInterface介面

   mpClientInterface= clientInterface;//這個clientInterface就是APS物件

    //清空強制使用配置

    for(int i = 0; i < AudioSystem::NUM_FORCE_USE; i++) {

       mForceUse[i] = AudioSystem::FORCE_NONE;

    }

    //輸出裝置有聽筒和揚聲器

   mAvailableOutputDevices = AudioSystem::DEVICE_OUT_EARPIECE |

                       AudioSystem::DEVICE_OUT_SPEAKER;

   //輸入裝置是內建的麥克（學名叫傳聲器）

   mAvailableInputDevices = AudioSystem::DEVICE_IN_BUILTIN_MIC;

#ifdef WITH_A2DP //和藍芽立體聲有關。

   mA2dpOutput = 0;

   mDuplicatedOutput = 0;

   mA2dpDeviceAddress = String8("");

#endif

   mScoDeviceAddress = String8(""); //SCO主要用於通話

  /*

    ①建立一個AudioOutputDescriptor物件，這個物件用來記錄並維護與

    輸出裝置（相當於硬體的音訊DSP）相關的資訊，例如使用該裝置的流個數、各個流的音量、

    該裝置所支援的取樣率、取樣精度等。其中，有一個成員mDevice用來表示目前使用的輸出裝置，

    例如耳機、聽筒、揚聲器等

 */

   AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();

    outputDesc->mDevice= (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER;

  /*

    ②還記得MixerThread的來歷嗎？openOutput導致AF建立了一個工作執行緒。

    該函式返回的是一個工作執行緒索引號

  */

   mHardwareOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                    &outputDesc->mSamplingRate,

                                   &outputDesc->mFormat,

                                   &outputDesc->mChannels,

                                   &outputDesc->mLatency,

                                   outputDesc->mFlags);

     ......

    //AMB維護了一個與裝置相關的key/value集合，下面將對應資訊加到該集合中。

    addOutput(mHardwareOutput,outputDesc);

    //③設定輸出裝置，就是設定DSP的資料流到底從什麼裝置出去，這裡設定的是從揚聲器出去

     setOutputDevice(mHardwareOutput,

                       (uint32_t)AudioSystem::DEVICE_OUT_SPEAKER,true);

    }

   //④更新不同策略使用的裝置

   updateDeviceForStrategy();

}

mHardwareOutput =mpClientInterface->openOutput(......)

注意：使用mA2dpOutput需要藍芽裝置連線上才會有意義。

說明：關於這一點，現在通過setOutputDevice來分析。

void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_toutput,

                                   uint32_tdevice, bool force, int delayMs)

{

    AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);

    //判斷是否是Duplicate輸出，和藍芽A2DP有關，後面再做分析

    if(outputDesc->isDuplicated()) {

       setOutputDevice(outputDesc->mOutput1->mId, device, force,delayMs);

       setOutputDevice(outputDesc->mOutput2->mId, device, force,delayMs);

       return;

  }

 // 初始設定的輸出裝置為聽筒和揚聲器

   uint32_tprevDevice = (uint32_t)outputDesc->device();

   if ((device == 0 || device == prevDevice)&& !force) {

       return;

    }

  //現在設定新的輸出裝置為揚聲器，注意這是軟體層面上的設定

  outputDesc->mDevice = device;

     ......

  /*

    還需要硬體也做相應設定，主要是告訴DSP把它的輸出切換到某個裝置上，根據之前的分析，

   這個請求要傳送到AF中的MixerThread上，因為只有它擁有代表輸出裝置的AudioStreamOut

物件

 */

   AudioParameter param = AudioParameter();

    param.addInt(String8(AudioParameter::keyRouting),(int)device);

 /*

  上面的配置引數將投遞到APS的訊息佇列，而APS中建立的AudioCommandThread

  會取出這個配置引數，再投遞給AF中對應的MixerThread，最終由MixerThread處理。

  這個流程，將在耳機插拔事件處理中進行分析

*/

   mpClientInterface->setParameters(mHardwareOutput,

                                           param.toString(),delayMs);

   ......

}

voidAudioPolicyManagerBase::updateDeviceForStrategy()

{

    for(int i = 0; i < NUM_STRATEGIES; i++) {

       mDeviceForStrategy[i] =

                            getDeviceForStrategy((routing_strategy)i,false);

    }

}

//routing_strategy:路由策略

enum routing_strategy {

           STRATEGY_MEDIA, 

           STRATEGY_PHONE,

           STRATEGY_SONIFICATION,

           STRATEGY_DTMF,

           NUM_STRATEGIES

        }

AudioPolicyManagerBase::getStrategy(AudioSystem::stream_typestream)

{

    switch(stream) {

    caseAudioSystem::VOICE_CALL:

    caseAudioSystem::BLUETOOTH_SCO:

        return STRATEGY_PHONE; //PHONE路由策略

    caseAudioSystem::RING:

    caseAudioSystem::NOTIFICATION:

    caseAudioSystem::ALARM:

    caseAudioSystem::ENFORCED_AUDIBLE:

       return STRATEGY_SONIFICATION; //SONIFICATION路由策略

    caseAudioSystem::DTMF:

       return STRATEGY_DTMF;  //DTMF路由策略

   default:

       LOGE("unknown stream type");

    caseAudioSystem::SYSTEM:

    caseAudioSystem::TTS:

    caseAudioSystem::MUSIC:

       return STRATEGY_MEDIA;//media 路由策略

    }

}

status_t AudioTrack::set(int streamType,uint32_tsampleRate,int format,

                          int channels,intframeCount,uint32_t flags,

                          callback_t cbf,void*user,int notificationFrames,

                          constsp<IMemory>& sharedBuffer, bool threadCanCallJava)

{

......

   //得到AF中一個工作執行緒的索引號

     audio_io_handle_toutput = AudioSystem::getOutput(

                                   (AudioSystem::stream_type)streamType,

                                   sampleRate,format, channels,

                                    (AudioSystem::output_flags)flags);

   ......

//建立Track，最終會調到AF的createTrack

status_t status = createTrack(streamType,sampleRate, format, channelCount,

                                  frameCount,flags, sharedBuffer, output);

audio_io_handle_tAudioSystem::getOutput(stream_type stream,

                                    uint32_tsamplingRate,

                                    uint32_tformat,

                                    uint32_tchannels,

                                    output_flagsflags)

{

   audio_io_handle_t output = 0;

    ......

    if(output == 0) {

       const sp<IAudioPolicyService>& aps =

                                     AudioSystem::get_audio_policy_service();

        if(aps == 0) return 0;

     //呼叫AP的getOutput函式

       output = aps->getOutput(stream, samplingRate, format, channels,flags);

        if((flags & AudioSystem::OUTPUT_FLAG_DIRECT) == 0) {

           Mutex::Autolock _l(gLock);

         //把這個stream和output的對應關係儲存到map中

           AudioSystem::gStreamOutputMap.add(stream, output);

        }

    }

    returnoutput;

}

audio_io_handle_t AudioPolicyService::getOutput(

                          AudioSystem::stream_typestream, uint32_t samplingRate,

                          uint32_tformat,uint32_t channels,

                          AudioSystem::output_flagsflags)

{

   //和硬體廠商的實現相關，所以交給AudioPolicyInterface處理

   //這裡將由AudioPolicyManagerBase處理

    Mutex::Autolock _l(mLock);

    returnmpPolicyManager->getOutput(stream, samplingRate, format, channels,

                                             flags);

}

audio_io_handle_tAudioPolicyManagerBase::getOutput(

                     AudioSystem::stream_typestream, uint32_t samplingRate,

                     uint32_t format,uint32_tchannels,

                     AudioSystem::output_flagsflags)

{

   audio_io_handle_t output = 0;

    uint32_tlatency = 0;

   //根據流型別得到對應的路由策略，這個我們已經見過了，MUSIC型別返回MUSIC策略

   routing_strategystrategy = getStrategy((AudioSystem::stream_type)stream);

  //根據策略得到使用這個策略的輸出裝置（指揚聲器之類的），以後再看這個函式

    uint32_tdevice = getDeviceForStrategy(strategy);

......

   //看這個裝置是不是與藍芽的A2DP相關

   uint32_ta2dpDevice = device & AudioSystem::DEVICE_OUT_ALL_A2DP;

   if(AudioSystem::popCount((AudioSystem::audio_devices)device) == 2) {

#ifdef WITH_A2DP

     //對於有A2DP支援，a2dpUsedForSonification函式直接返回true

  if (a2dpUsedForSonification() &&a2dpDevice != 0) {

      //和DuplicatingThread相關，以後再看

        output = mDuplicatedOutput;

 } else

#endif

       {

        output = mHardwareOutput; //使用非藍芽的混音輸出執行緒

        }

    } else{

#ifdef WITH_A2DP

        if(a2dpDevice != 0) {

           //使用藍芽的混音輸出執行緒

           output = mA2dpOutput;

        }else

#endif

        {

          output = mHardwareOutput;

        }

    }

  returnoutput;

}

status_tAudioFlinger::PlaybackThread::Track::start()

{

   status_t status = NO_ERROR;

    sp<ThreadBase> thread = mThread.promote();

     ......

        if(!isOutputTrack() && state != ACTIVE && state != RESUMING) {

           thread->mLock.unlock();

          //呼叫AudioSystem的startOutput

           status = AudioSystem::startOutput(thread->id(),

                                  (AudioSystem::stream_type)mStreamType);

            thread->mLock.lock();

        }

      PlaybackThread *playbackThread = (PlaybackThread *)thread.get();

      playbackThread->addTrack_l(this);//把這個Track加入到活躍Track陣列中

    returnstatus;

}

status_tAudioSystem::startOutput(audio_io_handle_t output,

                                         AudioSystem::stream_typestream)

{

   constsp<IAudioPolicyService>& aps =

                                       AudioSystem::get_audio_policy_service();

  if (aps== 0) return PERMISSION_DENIED;

    //呼叫AP的startOutput，最終由AMB完成實際功能

    returnaps->startOutput(output, stream);

}

status_tAudioPolicyManagerBase::startOutput(audio_io_handle_t output,

                                         AudioSystem::stream_typestream)

{

    //根據output找到對應的AudioOutputDescriptor

   ssize_t index = mOutputs.indexOfKey(output);

    AudioOutputDescriptor*outputDesc = mOutputs.valueAt(index);

   //找到對應流使用的路由策略

   routing_strategy strategy =getStrategy((AudioSystem::stream_type)stream);

   //增加outputDesc中該流的使用計數，1表示增加1

    outputDesc->changeRefCount(stream, 1);

//getNewDevice將得到一個裝置，setOutputDevice將使用這個裝置進行路由切換。

//至於setOutputDevice，我們在分析耳機插入事件時再來講解

   setOutputDevice(output, getNewDevice(output));

    //設定音量，讀者可自行分析

    checkAndSetVolume(stream,mStreams[stream].mIndexCur, output,

                         outputDesc->device());

  returnNO_ERROR;

}

uint32_tAudioPolicyManagerBase::getNewDevice(audio_io_handle_t output,

                                                        bool fromCache)

{

   uint32_t device = 0;

   AudioOutputDescriptor*outputDesc = mOutputs.valueFor(output);

  /*

    isUsedByStrategy判斷某個策略是否正在被使用，之前曾通過changeRefCount為

    MUSIC流使用計數增加了1，所以使用MUSIC策略的個數至少為1，這表明，此裝置正在使用該策略。

    一旦得到當前outputDesc使用的策略，便可根據該策略找到對應的裝置。

    注意if和else的順序，它代表了系統優先使用的策略,以第一個判斷為例，

    假設系統已經插上耳機，並且處於通話狀態時，而且強制使用了揚聲器，那麼聲音都從揚聲器出。

    這時，如果想聽音樂的話，則應首先使用STRATEGY_PHONE的對應裝置，此時就是揚聲器。

    所以音樂將從揚聲器出來，而不是耳機。上面僅是舉例，具體的情況還要綜合考慮Audio

    系統中的其他資訊。另外如果fromCache為true，將直接從內部儲存的舊資訊中得到裝置，

    關於這個問題，在後面的耳機插入事件處理中再做分析

   */

    if(mPhoneState == AudioSystem::MODE_IN_CALL ||

       outputDesc->isUsedByStrategy(STRATEGY_PHONE)) {

       device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION)) {

       device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA)) {

       device = getDeviceForStrategy(STRATEGY_MEDIA, fromCache);

    } elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF)) {

       device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);

    }

    returndevice;

}

提醒：讀者可自行分析stop的處理方式，基本上是start的逆向處理過程。

private class AudioServiceBroadcastReceiverextends BroadcastReceiver{

@Override

       public void onReceive(Context context, Intent intent) {

           String action = intent.getAction();

       ......

                  //如果該事件是耳機插拔事件

        elseif (action.equals(Intent.ACTION_HEADSET_PLUG)) {

                //取得耳機的狀態

               int state = intent.getIntExtra("state", 0);

               int microphone =intent.getIntExtra("microphone", 0);

               if (microphone != 0) {

                 //察看已連線裝置是不是已經有了耳機，耳機的裝置號為0x4，

                //這個和AudioSystem.h定義的裝置號是一致的

                    boolean isConnected =mConnectedDevices.containsKey(

                              AudioSystem.DEVICE_OUT_WIRED_HEADSET);

                    //如果之前有耳機而現在沒有，則認為是耳機拔出事件

                    if (state == 0 &&isConnected) {

                        //設定Audio系統的裝置連線狀態，耳機為Unavailable

                        AudioSystem.setDeviceConnectionState(

                                AudioSystem.DEVICE_OUT_WIRED_HEADSET,

                               AudioSystem.DEVICE_STATE_UNAVAILABLE,

                                "");

               //從已連線裝置中去掉耳機裝置

               mConnectedDevices.remove(AudioSystem.DEVICE_OUT_WIRED_HEADSET);

         } //如果state為1，並且之前沒有耳機連線,則處理這個耳機插入事件

          else if (state == 1 && !isConnected){

             //設定Audio系統的裝置連線狀態，耳機為Available

                    AudioSystem.setDeviceConnectionState(

                        AudioSystem.DEVICE_OUT_WIRED_HEADSET,

                        AudioSystem.DEVICE_STATE_AVAILABLE,

                        "");

             //已連線裝置中增加耳機  

             mConnectedDevices.put(

                         new Integer(AudioSystem.DEVICE_OUT_WIRED_HEADSET),

                         "");

                    }

               }

......

  publicstatic native int setDeviceConnectionState(int device, int state,

                                                             String device_address);

//注意我們傳入的引數，device為0X4表示耳機，state為1，device_address為””

static int android_media_AudioSystem_setDeviceConnectionState(

                                      JNIEnv*env, jobject thiz, jint

                                      device,jint state, jstring device_address)

{

    constchar *c_address = env->GetStringUTFChars(device_address, NULL);

    intstatus = check_AudioSystem_Command(

    //呼叫Native AudioSystem的setDeviceConnectionState

    AudioSystem::setDeviceConnectionState(

                 static_cast<AudioSystem::audio_devices>(device),

                 static_cast<AudioSystem::device_connection_state>(state),

                c_address));

   env->ReleaseStringUTFChars(device_address, c_address);

    returnstatus;

}

status_tAudioSystem::setDeviceConnectionState(audio_devices device,

                                                       device_connection_state state,

                                                       const char *device_address)

{

    constsp<IAudioPolicyService>& aps =

                                       AudioSystem::get_audio_policy_service();

    if(aps == 0) return PERMISSION_DENIED;

    //轉到AP去，最終由AMB處理

    returnaps->setDeviceConnectionState(device, state, device_address);

}

status_tAudioPolicyManagerBase::setDeviceConnectionState(

                  AudioSystem::audio_devicesdevice,

                  AudioSystem::device_connection_statestate,

                  const char *device_address)

{

    //一次只能設定一個裝置

    if(AudioSystem::popCount(device) != 1) return BAD_VALUE;

     ......

     //根據裝置號判斷是不是輸出裝置，耳機肯定屬於輸出裝置

   if(AudioSystem::isOutputDevice(device)) {

      switch (state)

        {

       case AudioSystem::DEVICE_STATE_AVAILABLE:

          //處理耳機插入事件，mAvailableOutputDevices儲存已連線的裝置

           //這個耳機是剛連上的，所以不走下面if分支

           if (mAvailableOutputDevices & device) {

               //啟用過了，就不再啟用了。

               return INVALID_OPERATION;

           }

           //現在已連線裝置中多了一個耳機

           mAvailableOutputDevices |= device;

             ....

         }

        //① getNewDevice之前已分析過了，這次再看

         uint32_t newDevice =getNewDevice(mHardwareOutput, false);

         //②更新各種策略使用的裝置

          updateDeviceForStrategy();

         //③設定新的輸出裝置

          setOutputDevice(mHardwareOutput,newDevice);

     ......

}

uint32_tAudioPolicyManagerBase::getNewDevice(audio_io_handle_t output,

                                                       bool fromCache)

{  //注意我們傳入的引數，output為mHardwardOutput,fromCache為false

    uint32_tdevice = 0;

    //根據output找到對應的AudioOutputDescriptor，這個物件儲存了一些資訊

   AudioOutputDescriptor *outputDesc = mOutputs.valueFor(output);

    if(mPhoneState == AudioSystem::MODE_IN_CALL ||

         outputDesc->isUsedByStrategy(STRATEGY_PHONE))

    {

       device = getDeviceForStrategy(STRATEGY_PHONE, fromCache);

    }

     elseif (outputDesc->isUsedByStrategy(STRATEGY_SONIFICATION))

    {

       device = getDeviceForStrategy(STRATEGY_SONIFICATION, fromCache);

     }

     elseif (outputDesc->isUsedByStrategy(STRATEGY_MEDIA))

    {

         //應用場景是正在聽歌，所以會走這個分支

        device= getDeviceForStrategy(STRATEGY_MEDIA, fromCache);

     }

    elseif (outputDesc->isUsedByStrategy(STRATEGY_DTMF))

    {

       device = getDeviceForStrategy(STRATEGY_DTMF, fromCache);

     }

    return device;

}

uint32_tAudioPolicyManagerBase::getDeviceForStrategy(

                                       routing_strategystrategy, bool fromCache)

{

   uint32_t device = 0;

    if (fromCache){//如果為true，則直接取之前的舊值

      return mDeviceForStrategy[strategy];

    }

  //如果fromCache為false，則需要重新計算策略所對應的裝置

    switch(strategy) {

    caseSTRATEGY_DTMF://先處理DTMF策略的情況

        if(mPhoneState != AudioSystem::MODE_IN_CALL) {

          //如果不處於電話狀態，則DTMF的策略和MEDIA策略對應同一個裝置

           device = getDeviceForStrategy(STRATEGY_MEDIA, false);

           break;

        }

         //如果處於電話狀態，則DTMF策略和PHONE策略用同一個裝置

    caseSTRATEGY_PHONE:

         //是PHONE策略的時候，先要考慮是不是使用者強制使用了某個裝置，例如強制使用揚聲器

       switch (mForceUse[AudioSystem::FOR_COMMUNICATION]) {

         ......

       case AudioSystem::FORCE_SPEAKER:

        ...... //如果沒有藍芽，則選擇揚聲器

           device = mAvailableOutputDevices &

                                           AudioSystem::DEVICE_OUT_SPEAKER;

           break;

        }

    break;

    caseSTRATEGY_SONIFICATION://SONIFICATION策略

        if(mPhoneState == AudioSystem::MODE_IN_CALL) {

           /*

             如果處於來電狀態，則和PHONE策略用同一個裝置。例如通話過程中我們強制使用

             揚聲器，那麼這個時候按撥號鍵，則按鍵聲也會從揚聲器出來

           */

           device = getDeviceForStrategy(STRATEGY_PHONE, false);

           break;

        }

       device = mAvailableOutputDevices & AudioSystem::DEVICE_OUT_SPEAKER;

        //如果不處於電話狀態，則SONIFICATION和MEDIA策略用同一個裝置

case STRATEGY_MEDIA: {

       //AUX_DIGITAL值為0x400，耳機不滿足該條件

       uint32_t device2 = mAvailableOutputDevices &

                                   AudioSystem::DEVICE_OUT_AUX_DIGITAL;

        if(device2 == 0) {

          //也不滿足WIRED_HEADPHONE條件

           device2 = mAvailableOutputDevices &

                                   AudioSystem::DEVICE_OUT_WIRED_HEADPHONE;

        }

        if(device2 == 0) {

           //滿足這個條件，所以device2為0x4，WIRED_HEADSET

           device2 = mAvailableOutputDevices &

                                      AudioSystem::DEVICE_OUT_WIRED_HEADSET;

        }

       if(device2 == 0) {

           device2 = mAvailableOutputDevices &

                                      AudioSystem::DEVICE_OUT_SPEAKER;

        }

      device |= device2; //最終device為0x4，WIRED_HEADSET

     }break;

   default:

      break;

    }

    returndevice;

}

voidAudioPolicyManagerBase::updateDeviceForStrategy()

{

    for(int i = 0; i < NUM_STRATEGIES; i++) {

  //重新計算每種策略使用的裝置，並儲存到mDeviceForStrategy中，起到了cache的作用

 mDeviceForStrategy[i] =

                              getDeviceForStrategy((routing_strategy)i,false);

    }

}

updateDevicdForStrategy();//先更新策略

//使用cache中的裝置，節省一次重新計算                        

uint32_t newDevice =getNewDevice(mHardwareOutput, true);

void AudioPolicyManagerBase::setOutputDevice(audio_io_handle_toutput,

                                       uint32_t device,bool force, int delayMs)

{

    ......

   //把這個請求要傳送到output對應的AF工作執行緒中

     AudioParameterparam = AudioParameter();

   //引數是key/vlaue鍵值對的格式

    param.addInt(String8(AudioParameter::keyRouting),(int)device);

   //mpClientInterface是AP物件，由它處理

    mpClientInterface->setParameters(mHardwareOutput,

                                            param.toString(),delayMs);

   //設定音量，不做討論，讀者可自行分析

   applyStreamVolumes(output, device, delayMs);

 }

voidAudioPolicyService::setParameters(audio_io_handle_t ioHandle,

                              constString8& keyValuePairs, int delayMs)

{

    //把這個請求加入到AudioCommandThread處理

    mAudioCommandThread->parametersCommand((int)ioHandle,

                                                 keyValuePairs, delayMs);

}

說明：這種通過一個佇列來協調兩個執行緒的方法，在多執行緒程式設計中非常常見，它也屬於生產者/消費者模型。

boolAudioPolicyService::AudioCommandThread::threadLoop()

{

    nsecs_twaitTime = INT64_MAX;

   mLock.lock();

    while(!exitPending())

    {

       while(!mAudioCommands.isEmpty()) {

           nsecs_t curTime = systemTime();

           if (mAudioCommands[0]->mTime <= curTime) {

               AudioCommand *command = mAudioCommands[0];

               mAudioCommands.removeAt(0);

               mLastCommand = *command;

               switch (command->mCommand) {

               case START_TONE:

                   ......

               case STOP_TONE:

                   ......  //TONE處理

                    mLock.lock();

                    }break;

               case SET_VOLUME: {

                    //設定音量

                    delete data;

                    }break;

               case SET_PARAMETERS: {

                    //處理路由設定請求

                     ParametersData *data =(ParametersData *)command->mParam;

                    //轉到AudioSystem處理，mIO的值為mHardwareOutput

                     command->mStatus =AudioSystem::setParameters(

                                          data->mIO,

                                         data->mKeyValuePairs);

                     if(command->mWaitStatus) {

                        command->mCond.signal();

                        mWaitWorkCV.wait(mLock);

                     }

                     delete data;

                     }break;

               ......

               default:

               }

}

status_tAudioSystem::setParameters(audio_io_handle_t ioHandle,

                                           constString8& keyValuePairs)

{

     constsp<IAudioFlinger>& af = AudioSystem::get_audio_flinger();

    //果然是交給AF處理，ioHandle看來一定就是工作執行緒索引號了

    returnaf->setParameters(ioHandle, keyValuePairs);

}

status_t AudioFlinger::setParameters(intioHandle,

                                   constString8& keyValuePairs)

{

   status_t result;

    // ioHandle == 0 表示和混音執行緒無關，需要直接設定到HAL物件中。

    if(ioHandle == 0) {

       AutoMutex lock(mHardwareLock);

       mHardwareStatus = AUDIO_SET_PARAMETER;

       //呼叫AudioHardwareInterface的引數設定介面

       result = mAudioHardware->setParameters(keyValuePairs);

       mHardwareStatus = AUDIO_HW_IDLE;

       return result;

    }

    sp<ThreadBase> thread;

    {

       Mutex::Autolock _l(mLock);

       //根據索引號找到對應混音執行緒。

       thread = checkPlaybackThread_l(ioHandle);

      }

      //我們只有一個MixerThread,交給它處理，這又是一個命令處理佇列

     result = thread->setParameters(keyValuePairs);

      returnresult;

    }

    returnBAD_VALUE;

}

bool AudioFlinger::MixerThread::threadLoop()

{

    ....

    while(!exitPending())

    {

       processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {// scope for mLock

           Mutex::Autolock _l(mLock);

          // checkForNewParameters_l最有嫌疑

           if (checkForNewParameters_l()) {

                ...

           }

      ......//其他處理

}

boolAudioFlinger::MixerThread::checkForNewParameters_l()

{

    boolreconfig = false;

    while(!mNewParameters.isEmpty()) {

       status_t status = NO_ERROR;

       String8 keyValuePair = mNewParameters[0];

       AudioParameter param = AudioParameter(keyValuePair);

       int value;

       ......

      //路由設定需要硬體參與，所以直接交給代表音訊輸出裝置的HAL物件處理

      status = mOutput->setParameters(keyValuePair);

      return reconfig;

}

status_tAudioHardware::AudioStreamOutMSM72xx::setParameters(

const String8& keyValuePairs)

{

   AudioParameter param = AudioParameter(keyValuePairs);

   String8 key = String8(AudioParameter::keyRouting);

    status_tstatus = NO_ERROR;

    intdevice;

    if(param.getInt(key, device) == NO_ERROR) {

       mDevices = device;

        //呼叫doRouting，mHardware就是AudioHardware物件

       status = mHardware->doRouting();

       param.remove(key);

    }

......

    returnstatus;

}

status_t AudioHardware::doRouting()

{

   Mutex::Autolock lock(mLock);

   uint32_t outputDevices = mOutput->devices();

   status_t ret = NO_ERROR;

    intsndDevice = -1;

      ......

      //做一些判斷，最終由doAudioRouteOrMute處理

     if((vr_mode_change) || (sndDevice != -1 && sndDevice != mCurSndDevice)) {

       ret = doAudioRouteOrMute(sndDevice);

       mCurSndDevice = sndDevice;

      }

    returnret;

}

status_t AudioHardware::doAudioRouteOrMute(uint32_tdevice)

{

   uint32_t rx_acdb_id = 0;

   uint32_t tx_acdb_id = 0;

   //只看看就行，對應硬體相關的程式碼，我們們就是打打醬油

   returndo_route_audio_dev_ctrl(device,

   mMode== AudioSystem::MODE_IN_CALL, rx_acdb_id, tx_acdb_id);

}

static status_t do_route_audio_dev_ctrl(uint32_tdevice, bool inCall,

uint32_t rx_acdb_id, uint32_t tx_acdb_id)

{

   uint32_t out_device = 0, mic_device = 0;

   uint32_t path[2];

    int fd= 0;

  //開啟音訊控制裝置

   fd =open("/dev/msm_audio_ctl", O_RDWR);

   path[0]= out_device;

   path[1]= rx_acdb_id;

    //通過ioctl切換裝置，一般系統呼叫都是返回-1表示出錯，這裡返回0表示出錯

    if(ioctl(fd, AUDIO_SWITCH_DEVICE, &path)) {

      close(fd);

      return -1;

    }

......

}

status_t AudioPolicyManagerBase::setDeviceConnectionState(

                     AudioSystem::audio_devicesdevice,

                    AudioSystem::device_connection_state state,

                     const char *device_address)

{

       ......

        switch (state)

        {

         case AudioSystem::DEVICE_STATE_AVAILABLE:

           mAvailableOutputDevices |= device;

#ifdef WITH_A2DP

           if (AudioSystem::isA2dpDevice(device)) {

                //專門處理A2DP裝置的連線

               status_t status = handleA2dpConnection(device, device_address);

         }

#endif

          ......

status_tAudioPolicyManagerBase::handleA2dpConnection(

                                        AudioSystem::audio_devicesdevice,

                                       const char*device_address)

{

   AudioOutputDescriptor *outputDesc = new AudioOutputDescriptor();

    outputDesc->mDevice= device;

    //先為mA2dpOutput建立一個MixerThread，這個和mHardwareOutput一樣

   mA2dpOutput =mpClientInterface->openOutput(&outputDesc->mDevice,

                                           &outputDesc->mSamplingRate,

                                           &outputDesc->mFormat,

                                            &outputDesc->mChannels,

                                           &outputDesc->mLatency,

                                           outputDesc->mFlags);

if (mA2dpOutput) {

 /*

   a2dpUsedForSonification永遠返回true，表示屬於SONIFCATION策略的音訊流聲音需要

同時從藍芽和DSP中傳出。屬於SONIFCATION策略的音訊流型別可檢視前面關於getStrategy的

分析，來電鈴聲、簡訊通知等屬於這一類

  */

        if(a2dpUsedForSonification()) {

          /*

           建立一個DuplicateOutput，注意它的引數,第一個是藍芽MixerThread

           第二個是DSPMixerThread

         */

           mDuplicatedOutput = mpClientInterface->openDuplicateOutput(

                                                       mA2dpOutput, mHardwareOutput);

        }

        if(mDuplicatedOutput != 0 ||

           !a2dpUsedForSonification()) {

           if (a2dpUsedForSonification()) {

                //建立一個AudioOutputDescriptor物件

                AudioOutputDescriptor *dupOutputDesc = new

                                                   AudioOutputDescriptor();

               dupOutputDesc->mOutput1 = mOutputs.valueFor(mHardwareOutput);

               dupOutputDesc->mOutput2 = mOutputs.valueFor(mA2dpOutput);

               ......

               //儲存mDuplicatedOutput和dupOutputDesc鍵值對

               addOutput(mDuplicatedOutput, dupOutputDesc);

               ......

           }

        }

}

......

int AudioFlinger::openDuplicateOutput(intoutput1, int output2)

{

    Mutex::Autolock_l(mLock);

    //output1對應藍芽的MixerThread

    MixerThread*thread1 = checkMixerThread_l(output1);

   //output2對應DSP的MixerThread

   MixerThread *thread2 = checkMixerThread_l(output2);

    //①建立DuplicatingThread，注意它第二個引數使用的，是代表藍芽的MixerThread

    DuplicatingThread *thread = new DuplicatingThread(this,

                                                     thread1,++mNextThreadId);

    //②加入代表DSP的MixerThread

   thread->addOutputTrack(thread2);

   mPlaybackThreads.add(mNextThreadId, thread);

    returnmNextThreadId;//返回DuplicatingThread的索引

}

AudioFlinger::DuplicatingThread::DuplicatingThread(constsp<AudioFlinger>&

                audioFlinger, AudioFlinger::MixerThread*mainThread,int id)

               :   MixerThread(audioFlinger,mainThread->getOutput(), id),

                    mWaitTimeMs(UINT_MAX)

{

//DT是MT的派生類，所以先要完成基類的構造，還記得MT的構造嗎？它會建立一個AudioMixer物件

  mType =PlaybackThread::DUPLICATING;

//把代表DSP的MT加入進來，我們們看看

   addOutputTrack(mainThread);

}

voidAudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)

{

   intframeCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate();

   //構造一個OutputTrack，它的第一個引數是MT

   OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread,

                                           this, mSampleRate, mFormat,

                                           mChannelCount,frameCount);

    if(outputTrack->cblk() != NULL) {

       thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f);

        //把這個outputTrack加入到mOutputTracks陣列儲存

       mOutputTracks.add(outputTrack);

       updateWaitTime();

    }

}

DuplicatingThread *thread = newDuplicatingThread(this,

                                                           thread1,++mNextThreadId);

thread->addOutputTrack(thread2);

AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(

        const wp<ThreadBase>& thread, DuplicatingThread*sourceThread,

       uint32_t sampleRate, int format,int channelCount,int frameCount)

        :Track(thread,NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate,

              format, channelCount, frameCount, NULL),//最後這個引數為NULL

         mActive(false),mSourceThread(sourceThread)

{

     /*

      OutputTrack從Track派生，所以需要先呼叫基類的構造，還記得Track建構函式

       中的事情嗎？它會建立一塊記憶體，至於是不是共享記憶體，由Track建構函式的最後一個引數決定。

        如果該值為NULL，表示沒有客戶端參與，則會在本程式內建立一塊記憶體，這塊記憶體的結構如

        圖7-4所示，前邊為CB物件，後邊為資料緩衝

     */

    //下面的這個thread物件為MT

   PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get();

    if(mCblk != NULL) {

       mCblk->out = 1;//表示DT將往MT中寫資料

       //和前面所分析的AT、AF中的處理何其相似！

       mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);

       mCblk->volume[0] = mCblk->volume[1] = 0x1000;

       mOutBuffer.frameCount = 0;

       //把這個Track加到MT的Track中

       playbackThread->mTracks.add(this);

}

boolAudioFlinger::DuplicatingThread::threadLoop()

{

   int16_t* curBuf = mMixBuffer;

   Vector< sp<Track> > tracksToRemove;

   uint32_t mixerStatus = MIXER_IDLE;

   nsecs_t standbyTime = systemTime();

    size_tmixBufferSize = mFrameCount*mFrameSize;

   SortedVector< sp<OutputTrack> > outputTracks;

    while(!exitPending())

    {

       processConfigEvents();

       mixerStatus = MIXER_IDLE;

        {

              ......

           //處理配置請求，和MT處理一樣

           const SortedVector< wp<Track> >& activeTracks =mActiveTracks;

           for (size_t i = 0; i < mOutputTracks.size(); i++) {

               outputTracks.add(mOutputTracks[i]);

           }

         //如果AT的Track停止了，則需要停止和MT共享的OutputTrack

        ifUNLIKELY((!activeTracks.size() && systemTime() > standbyTime)

               || mSuspended) {

               if (!mStandby) {

                    for (size_t i = 0; i <outputTracks.size(); i++) {

                       outputTracks[i]->stop();

                    }

                   mStandby = true;

                    mBytesWritten = 0;

               }

             ......

           //DT從MT派生，天然具有混音的功能，所以這部分功能和MT一致

           mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);

        }

        if(LIKELY(mixerStatus == MIXER_TRACKS_READY)) {

            //outputsReady將檢查OutputTracks對應的MT狀態

           if (outputsReady(outputTracks)) {

               mAudioMixer->process(curBuf);//使用AudioMixer物件混音

           } else {

               memset(curBuf, 0, mixBufferSize);

           }

           sleepTime = 0;

           writeFrames = mFrameCount;

        }

              ......

           if (sleepTime == 0) {

               standbyTime = systemTime() +kStandbyTimeInNsecs;

           for (size_t i = 0; i < outputTracks.size(); i++) {

               //將混音後的資料寫到outputTrack中

               outputTracks[i]->write(curBuf, writeFrames);

           }

           mStandby = false;

           mBytesWritten += mixBufferSize;

        }else {

           usleep(sleepTime);

        }

       tracksToRemove.clear();

       outputTracks.clear();

    }

    returnfalse;

}

boolAudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data,

                                                                uint32_t frames)

{

   //注意，此處的OutputTrack是DT和MT共享的

    Buffer *pInBuffer;

    BufferinBuffer;

   uint32_t channels = mCblk->channels;

    booloutputBufferFull = false;

   inBuffer.frameCount = frames;

   inBuffer.i16 = data;

   uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();

  if(!mActive && frames != 0) {

      //如果此Track沒有活躍，則呼叫start啟用

       start();

        ......

    }

     /*

       現在，AF中的資料傳遞有三個執行緒：一個DT，兩個MT。MT作為DT的二級消費者，

       可能由於某種原因來不及消費資料，所以DT中提供了一個緩衝佇列mBufferQueue，

       把MT來不及消費的資料儲存在這個緩衝佇列中。注意這個緩衝佇列容納的臨時緩衝

       個數是有限制的，其限制值由kMaxOverFlowBuffers控制，初始化為10個

   */

    while(waitTimeLeftMs) {

        //先消耗儲存在緩衝佇列的資料

        if(mBufferQueue.size()) {

           pInBuffer = mBufferQueue.itemAt(0);

        }else {

           pInBuffer = &inBuffer;

        }

        ......

       //獲取可寫緩衝，下面這句程式碼是否和AT中對應的程式碼很相似？

       if(obtainBuffer(&mOutBuffer, waitTimeLeftMs) ==

                              (status_t)AudioTrack::NO_MORE_BUFFERS){

              ......

               break;

         }

        uint32_toutFrames = pInBuffer->frameCount > mOutBuffer.frameCount ?

                                     mOutBuffer.frameCount: pInBuffer->frameCount;

        //將資料拷貝到DT和MT共享的那塊緩衝中去

       memcpy(mOutBuffer.raw, pInBuffer->raw,

                outFrames * channels * sizeof(int16_t));

        //更新寫位置

       mCblk->stepUser(outFrames);

        pInBuffer->frameCount-= outFrames;

       pInBuffer->i16 += outFrames * channels;

       mOutBuffer.frameCount -= outFrames;

       mOutBuffer.i16 += outFrames * channels;

        ......

     }//while 結束

       if(inBuffer.frameCount) {

       sp<ThreadBase> thread = mThread.promote();

        if(thread != 0 && !thread->standby()) {

           if (mBufferQueue.size() < kMaxOverFlowBuffers) {

               pInBuffer = new Buffer;

               pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels];

               pInBuffer->frameCount = inBuffer.frameCount;

               pInBuffer->i16 = pInBuffer->mBuffer;

              //拷貝舊資料到新的臨時緩衝

               memcpy(pInBuffer->raw, inBuffer.raw,

                        inBuffer.frameCount *channels * sizeof(int16_t));

              //儲存這個臨時緩衝

               mBufferQueue.add(pInBuffer);

          }

        }

}

    //如果資料全部寫完

        if(pInBuffer->frameCount == 0) {

            if (mBufferQueue.size()) {

               mBufferQueue.removeAt(0);

               delete [] pInBuffer->mBuffer;

               delete pInBuffer;//釋放緩衝佇列對應的資料緩衝

          } else {

               break;

           }

        }

}

   ......

    return outputBufferFull;

}

說明：DT還有別的一些細節本書中沒有涉及，讀者可以結合自己的情況進行分析和理解。

我很羨慕iOS的應用開發者，他們面臨的由於硬體變化導致的問題要少得多。

說明：這可能和我做過的應用太簡單有一定關係（就是ffmpeg編解碼MP3，然後播出來即可）。而libasound提供的API較多，在權衡各種情況後，我覺得它不適合快速簡單應用的開發。

說明：已記不得第一次接觸Desktop Check一詞是什麼時候了，或許當時還不叫Desktop Check，但我覺得它所蘊含的思想是正確的，是頗有價值的。

建議：無論怎麼說，資料I/O畢竟是Audio系統中關鍵之關鍵，所以請讀者一定要仔細閱讀，體會其中精妙所在。