android Audio設置音量流程及其binder通訊原理

Audio java部分代碼流程(4.1.2 version):

    在frameworks/base/media/java/android/media中:

    IAudioService.aidl提供瞭所有對外的接口函數,如下:

[cpp]  

interface IAudioService {  

      

    void adjustVolume(int direction, int flags);  

  

    void adjustSuggestedStreamVolume(int direction, int suggestedStreamType, int flags);  

      

    void adjustStreamVolume(int streamType, int direction, int flags);  

      

    void setStreamVolume(int streamType, int index, int flags);  

      

    void setStreamSolo(int streamType, boolean state, IBinder cb);  

         

    void setStreamMute(int streamType, boolean state, IBinder cb);  

  

    boolean isStreamMute(int streamType);  

  

    int getStreamVolume(int streamType);  

      

    int getStreamMaxVolume(int streamType);  

      

    int getLastAudibleStreamVolume(int streamType);  

  

    void setRingerMode(int ringerMode);  

    …………………..  

}  

這些函數的實現在服務AudioService.java中:

[cpp]  

public class AudioService extends IAudioService.Stub {  

        ……..  

}  

該服務在services/java/com/android/server/SystemServer.java中註冊進servicemanager中:

[cpp]  

492             try {  

493                 Slog.i(TAG, "Audio Service");  

494                 ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context));                                 

495             } catch (Throwable e) {  

496                 reportWtf("starting Audio Service", e);  

497             }  

    這樣在frameworks中可以通過ServiceManager.getService(Context.AUDIO_SERVICE)來獲得該服務。

    而AudioManager.java則實現這些函數瞭對外應用的接口,比如:

[cpp]  

496     public void adjustVolume(int direction, int flags) {  

497         IAudioService service = getService(); //  

498         try {  

499             service.adjustVolume(direction, flags);  

500         } catch (RemoteException e) {  

501             Log.e(TAG, "Dead object in adjustVolume", e);  

502         }  

503     }  

    這裡的getService()獲得的是前面的AudioService,如下:

[cpp] 

365     private static IAudioService getService()                                                                                

366     {  

367         if (sService != null) {  

368             return sService;  

369         }  

370         IBinder b = ServiceManager.getService(Context.AUDIO_SERVICE);  

371         sService = IAudioService.Stub.asInterface(b);  

372         return sService;  

373     }  

    要把AudioManager.java中的對外公開,則要在 core/java/android/app/ContextImpl.java中註冊:

[cpp] 

281         registerService(AUDIO_SERVICE, new ServiceFetcher() {                                                     

282                 public Object createService(ContextImpl ctx) {  

283                     return new AudioManager(ctx);  

284                 }});  

    而且,還要把這些函數變量等在api/current.txt中聲明:

[cpp] 

10353   public class AudioManager {  

10354     method public int abandonAudioFocus(android.media.AudioManager.OnAudioFocusChangeListener);  

10355     method public void adjustStreamVolume(int, int, int);                                             

10356     method public void adjustSuggestedStreamVolume(int, int, int);  

10357     method public void adjustVolume(int, int);  

10358     method public int getMode();  

10359     method public java.lang.String getParameters(java.lang.String);  

10360     method public int getRingerMode();  

10361     method public deprecated int getRouting(int);  

10362     method public int getStreamMaxVolume(int);  

10363     method public int getStreamVolume(int);  

10364     method public int getVibrateSetting(int);  

10365     method public boolean isBluetoothA2dpOn();  

   這樣在應用中用(AudioManager) getSystemService(Context.AUDIO_SERVICE);即可獲得服務,從而使用AudioManager.java中的方法然後看看比如setStreamVolume是如何從java調用到底層的:

1、應用調用比如mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, progress, 0);

2、AudioManager.java調用public void setStreamVolume(int streamType, int index, int flags){};

3、AudioService.java調用public void setStreamVolume(int streamType, int index, int flags){},在該函數中調用

[cpp] 

setStreamVolumeInt(mStreamVolumeAlias[streamType],                                                                                         

    831                                    index,    

    832                                    device,    

    833                                    false,    

    834                                    true);    

——–>    

   1002                 sendMsg(mAudioHandler,    

   1003                         MSG_PERSIST_VOLUME,    

   1004                         SENDMSG_QUEUE,    

   1005                         PERSIST_LAST_AUDIBLE,    

   1006                         device,    

   1007                         streamState,    

   1008                         PERSIST_DELAY);    

 

 

而mAudioHandler = new AudioHandler(),看看這個AudioHandler類:private class AudioHandler extends Handler {};——–>

所以調用該類重寫的handleMessage方法———>

[cpp] 

2940         @Override  

2941         public void handleMessage(Message msg) {  

2942  

2943             switch (msg.what) {  

2944   

2945                 case MSG_SET_DEVICE_VOLUME:  

2946                     setDeviceVolume((VolumeStreamState) msg.obj, msg.arg1);  

2947                     break;  

setDeviceVolume———> mStreamStates[streamType].applyDeviceVolume(getDeviceForStream(streamType));———->AudioSystem.setStreamVolumeIndex———>

setStreamVolumeIndex的定義在AudioSystem.java中——–>public static native int setStreamVolumeIndex(int stream, int index, int device);

setStreamVolumeIndex的JNI實現在base/core/jni/android_media_AudioSystem.cpp中———->

[cpp] 

178 static int  

179 android_media_AudioSystem_setStreamVolumeIndex(JNIEnv *env,                                                                   

180                                                jobject thiz,  

181                                                jint stream,  

182                                                jint index,  

183                                                jint device)  

184 {  

185     return check_AudioSystem_Command(  

186             AudioSystem::setStreamVolumeIndex(static_cast <audio_stream_type_t>(stream),  

187                                               index,  

188                                               (audio_devices_t)device));  

189 }  

AudioSystem類在av/media/libmedia/AudioSystem.cpp中———>

[cpp]  

666 status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,  

667                                            int index,  

668                                            audio_devices_t device)  

669 {  

670     const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();  

671     if (aps == 0) return PERMISSION_DENIED;  

672     return aps->setStreamVolumeIndex(stream, index, device);  

673 }  

到這裡就要涉及到進程間通訊binder的使用瞭,我們看AudioSystem::get_audio_policy_service()的實現:

[cpp] 

514 const sp<IAudioPolicyService>& AudioSystem::get_audio_policy_service()  

515 {  

516     gLock.lock();  

517     if (gAudioPolicyService == 0) {  

518         sp<IServiceManager> sm = defaultServiceManager();//取得BpServiceManager,通過這個代理可以調用BnServiceManager::onTransact,最後和ServiceManager通訊  

519         sp<IBinder> binder;  

520         do {  

521             binder = sm->getService(String16("media.audio_policy"));//從ServiceManager獲得遠程AudioPolicyService的句柄  

522             if (binder != 0)  

523                 break;  

524             ALOGW("AudioPolicyService not published, waiting…");  

525             usleep(500000); // 0.5 s  

526         } while (true);  

527         if (gAudioPolicyServiceClient == NULL) {  

528             gAudioPolicyServiceClient = new AudioPolicyServiceClient();  

529         }  

530         binder->linkToDeath(gAudioPolicyServiceClient);  

531         gAudioPolicyService = interface_cast<IAudioPolicyService>(binder);                 

532         gLock.unlock();  

533     } else {  

534         gLock.unlock();  

535     }  

536     return gAudioPolicyService;  

537 }  

上面531行interface_cast<IAudioPolicyService>(binder),interface_cast是一個模版,在frameworks/native/include/binder/IInterface.h中定義如下:

[cpp]  

42 inline sp<INTERFACE> interface_cast(const sp<IBinder>&obj)                 

43 {  

44     return INTERFACE::asInterface(obj);  

45 }  

展開後是IAudioPolicyService::asInterface(obj);而IAudioPolicyService::asInterface的實現在frameworks/av/include/media/IAudioPolicyService.h中,通過宏

[cpp]  

DECLARE_META_INTERFACE(AudioPolicyService)展開後得到的,DECLARE_META_INTERFACE定義在IInterface.h中:  

     74 #define DECLARE_META_INTERFACE(INTERFACE)                               \  

     75     static const android::String16 descriptor;                          \  

     76     static android::sp<I##INTERFACE> asInterface(                       \  

     77             const android::sp<android::IBinder>& obj);                  \  

     78     virtual const android::String16& getInterfaceDescriptor() const;    \  

     79     I##INTERFACE();                                                     \  

     80     virtual ~I##INTERFACE();  

76行展開即可得到IAudioPolicyService::asInterface的定義,而這個定義的實現也是在IInterface.h,通過宏來定義的:

[cpp]  

#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)  

    ……………………  

 89     android::sp<I##INTERFACE> I##INTERFACE::asInterface(                \  

 90             const android::sp<android::IBinder>& obj)                   \  

 91     {                                                                   \  

 92         android::sp<I##INTERFACE> intr;                                 \  

 93         if (obj != NULL) {                                              \  

 94             intr = static_cast<I##INTERFACE*>(                          \  

 95                 obj->queryLocalInterface(                               \  

 96                         I##INTERFACE::descriptor).get());               \  

 97             if (intr == NULL) {                                         \  

 98                 intr = new Bp##INTERFACE(obj);                          \  

 99             }                                                           \  

100         }                                                               \  

101         return intr;                                                    \  

102     }  

 

展開後最終是生成調用new BpAudioPolicyService(new BpBinder(handle)),這裡的handle是一個句柄;這樣我們最終得到瞭AudioPolicyService的代理BpAudioPolicyService,通過它就可以和AudioPolicyService的本地接口BnAudioPolicyService通訊瞭。

回到前面的AudioSystem.cpp,取得代理BpAudioPolicyService後調用aps->setStreamVolumeIndex,所以進入IAudioPolicyService.cpp:

class BpAudioPolicyService : public BpInterface<IAudioPolicyService>:

[cpp] 

233     virtual status_t setStreamVolumeIndex(audio_stream_type_t stream,                                                             

234                                           int index,  

235                                           audio_devices_t device)  

236     {  

237         Parcel data, reply;  

238         data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());  

239         data.writeInt32(static_cast <uint32_t>(stream));  

240         data.writeInt32(index);  

241         data.writeInt32(static_cast <uint32_t>(device));  

242         remote()->transact(SET_STREAM_VOLUME, data, &reply);  

243         return static_cast <status_t> (reply.readInt32());  

244     }  

242行的remote是通過繼承關系BpAudioPolicyService -> BpInterface -> BpRefBase,在類BpRefBase中定義的:

[cpp] 

inline  IBinder*        remote()                { return mRemote; }  

 IBinder* const          mRemote;  

這裡mRemote聲明為const,可見它是靜態不變,隻賦值一次,它是在前面獲取遠程服務AudioPolicyService時候創建的BpBinder對象(主要是打開瞭binder驅動,獲得FD描述符,並且內存映射瞭空間),所以調用BpBinder.cpp的transact函數:

[cpp]  

159 status_t BpBinder::transact(  

160     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)  

161 {  

162     // Once a binder has died, it will never come back to life.  

163     if (mAlive) {  

164         status_t status = IPCThreadState::self()->transact(  

165             mHandle, code, data, reply, flags);  

166         if (status == DEAD_OBJECT) mAlive = 0;  

167         return status;  

168     }  

169   

170     return DEAD_OBJECT;  

171 }  

從164行,調用IPCThreadState.cpp的transact,這裡就是最終和binder驅動打交道的地方瞭,165行通過mHandle,底層binder驅動知道瞭傳輸數據的目標地址為mediaserver進程,binder驅動將數據拷貝到service的內存共享空間,並告訴service這個內核空間相對用戶空間的偏移,遠程服務端就可以不用再次拷貝數據,直接從用戶空間就可以讀取數據瞭, 這樣remote()->transact(SET_STREAM_VOLUME, data, &reply)就通過binder傳遞到BnAudioPolicyService中瞭,這樣就調用IAudioPolicyService.cpp的BnAudioPolicyService::onTransact函數來處理該請求(但由於繼承關系最終是派發到Bn的派生類AudioPolicyService::onTransact來處理,不過我們後面也會發現派生類又調回Bn類的onTransact去處理,很有意思啊),我們看看BnAudioPolicyService是如何獲得remote()->transact(SET_STREAM_VOLUME, data, &reply)的請求的,這樣要從AudioPolicyService是如何將自己的服務添加到servicemanager中的說起,在frameworks/av/media/mediaserver/main_mediaserver.cpp中:

[cpp]  

34 int main(int argc, char** argv)  

35 {  

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

37     sp<IServiceManager> sm = defaultServiceManager();  

38     ALOGI("ServiceManager: %p", sm.get());  

39     AudioFlinger::instantiate();  

40     MediaPlayerService::instantiate();  

41     CameraService::instantiate();  

42     AudioPolicyService::instantiate();                                                                                          

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

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

45 }   

36行,由於main_mediaserver.cpp是編譯成一個可執行文件,就是它的啟動是作為服務在一個獨立的進程中運行瞭,Main_MediaServer主函數由init.rc在啟動時調用,先明白這點,然後看:

frameworks/native/libs/binder/ProcessState.cpp:

[cpp] 

74 sp<ProcessState> ProcessState::self()  

75 {  

76     Mutex::Autolock _l(gProcessMutex);  

77     if (gProcess != NULL) {  

78         return gProcess;  

79     }  

80     gProcess = new ProcessState;  

81     return gProcess;  

82 }  

從77行可知,這是一個單例模式,在這個進程中以後再調用這個函數的話,就直接返回78行,這裡我們第一次進來,所以跑到80行,進入ProcessState構造函數:

[cpp] 

335 ProcessState::ProcessState()  

336     : mDriverFD(open_driver())  

337     , mVMStart(MAP_FAILED)  

338     , mManagesContexts(false)  

339     , mBinderContextCheckFunc(NULL)  

340     , mBinderContextUserData(NULL)  

341     , mThreadPoolStarted(false)  

342     , mThreadPoolSeq(1)  

343 {     

344     if (mDriverFD >= 0) {  

345         // XXX Ideally, there should be a specific define for whether we  

346         // have mmap (or whether we could possibly have the kernel module  

347         // availabla).  

348 #if !defined(HAVE_WIN32_IPC)  

349         // mmap the binder, providing a chunk of virtual address space to receive transactions.  

350         mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);  

……………………………  

}  

336行打開Binder設備文件/dev/binder,並將打開設備文件描述符保存在成員變量mDriverFD中;350行mmap來把設備文件/dev/binder映射到內存中,這樣我們就有瞭一塊共享內存。

回到main_mediaserver.cpp,37行defaultServiceManager(),在frameworks/native/libs/binder/IServiceManager.cpp中:

[cpp]  

34 sp<IServiceManager> defaultServiceManager()                                                                            

35 {     

36     if (gDefaultServiceManager != NULL) return gDefaultServiceManager;  

37       

38     {  

39         AutoMutex _l(gDefaultServiceManagerLock);  

40         if (gDefaultServiceManager == NULL) {  

41             gDefaultServiceManager = interface_cast<IServiceManager>(  

42                 ProcessState::self()->getContextObject(NULL));  

43         }  

44     }  

45   

46     return gDefaultServiceManager;  

47 }  

和前面一樣,也是一個單例模式,第一次進來肯定為NULL,所以進入41行,ProcessState::self()前面已經運行過一次,直接調用getContextObject(NULL),註意傳進來的是NULL參數,表示和ServiceManager通訊:

[cpp]  

89 sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& caller)  

90 {  

91     return getStrongProxyForHandle(0);                                                                                                

92 }  

getStrongProxyForHandle(0)最終會調用new BpBinder(0),這樣我們就得到瞭ServiceManager的代理BpBinder,回到IServiceManager.cpp的41行,就變成瞭interface_cast<IServiceManager>(new BpBinder(0)),interface_cast在前面已經分析過,所以最後變成new BpServiceManager(new BpBinder(0))。接著進入main_mediaserver.cpp42行AudioPolicyService::instantiate(),先看看frameworks/av/services/audioflinger/AudioPolicyService.h中的繼承關系:

[cpp]  

37 class AudioPolicyService :  

38     public BinderService<AudioPolicyService>,                                                                               

39     public BnAudioPolicyService,  

40 //    public AudioPolicyClientInterface,  

41     public IBinder::DeathRecipient  

AudioPolicyService並沒有實現instantiate方法,而是繼承BinderService得到的,該類在frameworks/native/include/binder/BinderService.h中:

[cpp] 

33 template<typename SERVICE>  

34 class BinderService                                                                                                              

35 {  

36 public:  

37     static status_t publish(bool allowIsolated = false) {  

38         sp<IServiceManager> sm(defaultServiceManager());  

39         return sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);  

40     }  

41   

42     static void publishAndJoinThreadPool(bool allowIsolated = false) {  

43         sp<IServiceManager> sm(defaultServiceManager());  

44         sm->addService(String16(SERVICE::getServiceName()), new SERVICE(), allowIsolated);  

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

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

47     }  

48       

49     static void instantiate() { publish(); }  

50       

51     static status_t shutdown() {  

52         return NO_ERROR;  

53     }  

54 };  

這是一個類模版,最終調用39行,得到sm->addService(String16(AudioPolicyService::getServiceName()), new AudioPolicyService(), false)即:

BpServiceManager(new BpBinder(0))->addService(String16("media.audio_policy", new AudioPolicyService(), false),進入BpServiceManger::addService的實現,這個函數實現在frameworks/native/libs/binder/IServiceManager.cpp:

[cpp]  

154     virtual status_t addService(const String16& name, const sp<IBinder>&service, bool allowIsolated)  

156     {  

157         Parcel data, reply;  

158         data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());  

159         data.writeString16(name);  

160         data.writeStrongBinder(service);  

161         data.writeInt32(allowIsolated ? 1 : 0);  

162         status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);  

163         return err == NO_ERROR ? reply.readExceptionCode() : err;  

164     }  

這裡162行remote流程和前面分析的差不多,最終調用IPCThreadState.cpp的transact,這裡就是最終和binder驅動打交道的地方瞭,binder即為前面main_mediaserver.cpp中36行ProcessState::ProcessState打開的驅動,用這塊共享內存和servicemanager打交道,在底層的內核空間binder驅動會根據傳進來的mHandle值判斷目標服務地址,這裡的mHandle為0,所以調整servermanager的buffer指向本地內存共享空間,接著往下看main_mediaserver.cpp的43行ProcessState::self()->startThreadPool(),在frameworks/native/libs/binder/ProcessState.cpp中:

[cpp] 

136 void ProcessState::startThreadPool()  

137 {  

138     AutoMutex _l(mLock);  

139     if (!mThreadPoolStarted) {  

140         mThreadPoolStarted = true;  

141         spawnPooledThread(true);                                                                                                               

142     }  

143 }  

看141行:

[cpp]  

286 void ProcessState::spawnPooledThread(bool isMain)                                                                          

287 {  

288     if (mThreadPoolStarted) {  

289         int32_t s = android_atomic_add(1, &mThreadPoolSeq);  

290         char buf[16];  

291         snprintf(buf, sizeof(buf), "Binder_%X", s);  

292         ALOGV("Spawning new pooled thread, name=%s\n", buf);  

293         sp<Thread> t = new PoolThread(isMain);  

294         t->run(buf);  

295     }  

296 }  

293行創建瞭線程,PoolThread類繼承列thread類,ProcessState.cpp中::

[cpp]  

56 class PoolThread : public Thread  

57 {  

58 public:  

59     PoolThread(bool isMain)  

60         : mIsMain(isMain)  

61     {  

62     }  

63   

64 protected:  

65     virtual bool threadLoop()                                                                                                      

66     {  

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

68         return false;  

69     }  

70   

71     const bool mIsMain;  

72 };  

294行執行線程,thread在frameworks/native/libs/utils/Threads.cpp中,這樣run函數最終調用子類的threadLoop函數,看67行,調用的和main_mediaserver.cpp的44行一樣,進入IPCThreadState.cpp中,result =talkWithDriver()等待client請求,最終會調用 executeCommand(cmd)函數來處理請求,而在executeCommand函數中,最終會調用BBinder::transact來真正處理Client的請求,接下來再看一下BBinder::transact的實現,frameworks/native/libs/binder/Binder.cpp中:

[cpp] 

 97 status_t BBinder::transact(  

 98     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)  

 99 {  

100     data.setDataPosition(0);  

101   

102     status_t err = NO_ERROR;  

103     switch (code) {  

104         case PING_TRANSACTION:                                                                                                

105             reply->writeInt32(pingBinder());  

106             break;  

107         default:  

108             err = onTransact(code, data, reply, flags);  

109             break;  

110     }  

111   

112     if (reply != NULL) {  

113         reply->setDataPosition(0);  

114     }  

115   

116     return err;  

117 }  

108行,調用onTransact方法,由於這裡的繼承關系,在前面分析main_mediaserver.cpp的42行AudioPolicyService::instantiate()就知道,這裡創建的是AudioPolicyService類,這樣由於虛函數onTransact的繼承關系,最終調用瞭AudioPolicyService的onTransact方法,AudioPolicyService.cpp中:

[cpp]  

610 status_t AudioPolicyService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)  

612 {  

613     return BnAudioPolicyService::onTransact(code, data, reply, flags);  

614 }  

613行調用的還是基類BnAudioPolicyService的方法.

到這裡BpAudioPolicyService和BnAudioPolicyService的binder通訊關系就完成瞭,回到前面IAudioPolicyService.cpp中的242行remote()->transact(SET_STREAM_VOLUME, data, &reply);這裡傳進來的是SET_STREAM_VOLUME,所以調用BnAudioPolicyService::onTransact:

[cpp]  

512         case SET_STREAM_VOLUME:{                                                                                           

513             CHECK_INTERFACE(IAudioPolicyService, data, reply);  

514             audio_stream_type_t stream =  

515                     static_cast <audio_stream_type_t>(data.readInt32());  

516             int index = data.readInt32();  

517             audio_devices_t device = static_cast <audio_devices_t>(data.readInt32());  

518             reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream,  

519                                                                           index,  

520                                                                           device)));  

521             return NO_ERROR;  

522         } break;  

518行AudioPolicyService覆蓋瞭BpAudioPolicyService的setStreamVolumeIndex方法,所以最終調用瞭AudioPolicyService.cpp的setStreamVolumeIndex方法:

[cpp] 

380 status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream,  

381                                                   int index,  

382                                                   audio_devices_t device)  

383 {  

384     if (mpAudioPolicy == NULL) {  

385         return NO_INIT;  

386     }  

387     if (!settingsAllowed()) {  

388         return PERMISSION_DENIED;  

389     }  

390     if (uint32_t(stream) >= AUDIO_STREAM_CNT) {  

391         return BAD_VALUE;  

392     }  

393   

394     if (mpAudioPolicy->set_stream_volume_index_for_device) {                                                             

395         return mpAudioPolicy->set_stream_volume_index_for_device(mpAudioPolicy,  

396                                                                 stream,  

397                                                                 index,  

398                                                                 device);  

399     } else {  

400         return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index);  

401     }  

402 }  

總結上面binder的通訊機制,理解瞭類之間的繼承派生關系,也就能把來龍去脈弄清楚,主要還是熟悉C++才行,還有要理解binder通訊的設計原理,即每個服務或者想要獲得服務的進程都會打開binder節點,並且內存映射有一塊空間,傳送數據時候,binder驅動根據client傳進來的數據大小、位置和目標service(在驅動中用target_proc來表示),用binder_alloc_buf函數在目標service之前mmap時候分配的內核空間中申請空間,然後用copy_from_user將數據從用戶空間拷貝到內核的這塊空間中來,又因為service端之前mmap申請內核空間的時候已經記錄瞭這塊空間在內核中和用戶空間的偏移量,從而計算binder_alloc_buf分配得到的內核空間對應用戶空間的地址,最後將該地址拷貝到service的用戶空間,service端就可以得到數據瞭,通過這樣的淺拷貝即可實現進程間傳輸數據隻用拷貝一次即可的原理。繼續從AudioPolicyService.cpp往下走。先看它的構造函數:

[cpp]  

58 AudioPolicyService::AudioPolicyService()  

59     : BnAudioPolicyService() , mpAudioPolicyDev(NULL) , mpAudioPolicy(NULL)  

60 {  

61     char value[PROPERTY_VALUE_MAX];  

62     const struct hw_module_t *module;  

63     int forced_val;  

64     int rc;  

65   

66     Mutex::Autolock _l(mLock);  

67   

68     // start tone playback thread  

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

70     // start audio commands thread  

71     mAudioCommandThread = new AudioCommandThread(String8("ApmCommand"));  

72   

73     /* instantiate the audio policy manager */  

74     rc = hw_get_module(AUDIO_POLICY_HARDWARE_MODULE_ID, &module);  

75     if(rc)                                                                                                             

76         return;  

77   

78     rc = audio_policy_dev_open(module, &mpAudioPolicyDev);  

79     ALOGE_IF(rc, "couldn't open audio policy device (%s)", strerror(-rc));  

80     if (rc)  

81         return;  

82   

83     rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this,  

84                                                &mpAudioPolicy);  

85     ALOGE_IF(rc, "couldn't create audio policy (%s)", strerror(-rc));  

86     if (rc)  

87         return;  

88   

89     rc = mpAudioPolicy->init_check(mpAudioPolicy);  

90     ALOGE_IF(rc, "couldn't init_check the audio policy (%s)", strerror(-rc));  

91     if (rc)  

92         return;  

  …………………..  

  }  

74行AUDIO_POLICY_HARDWARE_MODULE_ID定義在libhardware/include/hardware/audio_policy.h中,

    #define AUDIO_POLICY_HARDWARE_MODULE_ID "audio_policy"

根據hw_get_module的判斷關系,看hardware/libhardware_legacy/audio/Android.mk可知,最終調用的是audio_policy.default.so,通過hw_get_module函數的load(class_id, path, module)打開audio_policy.default.so並返回句柄,接著78行audio_policy_dev_open,在libhardware/include/hardware/audio_policy.h

[cpp] 

424 static inline int audio_policy_dev_open(const hw_module_t* module,  

425                                     struct audio_policy_device** device)  

426 {  

427     return module->methods->open(module, AUDIO_POLICY_INTERFACE,  

428                                  (hw_device_t**)device);  

429 }  

這樣就調用瞭hardware/libhardware_legacy/audio/audio_policy_hal.cpp的open方法:

[cpp] 

406 static int legacy_ap_dev_open(const hw_module_t* module, const char* name, hw_device_t** device)  

408 {  

409     struct legacy_ap_device *dev;  

411     if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0)  

412         return -EINVAL;  

414     dev = (struct legacy_ap_device *)calloc(1, sizeof(*dev));                                                      

415     if (!dev)  

416         return -ENOMEM;  

418     dev->device.common.tag = HARDWARE_DEVICE_TAG;  

419     dev->device.common.version = 0;  

420     dev->device.common.module = const_cast<hw_module_t*>(module);  

421     dev->device.common.close = legacy_ap_dev_close;  

422     dev->device.create_audio_policy = create_legacy_ap;  

423     dev->device.destroy_audio_policy = destroy_legacy_ap;  

425     *device = &dev->device.common;  

427     return 0;  

428 }  

結構體legacy_ap_device定義:

[cpp]  

40 struct legacy_ap_device {                                                                                                                       

41     struct audio_policy_device device;  

42 };  

結構體audio_policy_device定義:

[cpp]  

410 struct audio_policy_device {                                                                                                    

411     struct hw_device_t common;  

412   

413     int (*create_audio_policy)(const struct audio_policy_device *device,  

414                                struct audio_policy_service_ops *aps_ops,  

415                                void *service,  

416                                struct audio_policy **ap);  

417   

418     int (*destroy_audio_policy)(const struct audio_policy_device *device,  

419                                 struct audio_policy *ap);  

420 };  

所以這裡open的425行*device = &dev->device.common賦值的雖然是結構體audio_policy_device的成員common的地址,但是common位於結構體首地址,也就是相當於返回瞭audio_policy_device結構體的地址。所以接著AudioPolicyService.cpp的83行調用的是audio_policy_device的create_audio_policy,它指向create_legacy_ap函數:

[cpp]  

311 static int create_legacy_ap(const struct audio_policy_device *device,  

312                             struct audio_policy_service_ops *aps_ops,  

313                             void *service,  

314                             struct audio_policy **ap)  

315 {  

316     struct legacy_audio_policy *lap;  

317     int ret;  

318   

319     if (!service || !aps_ops)  

320         return -EINVAL;  

321   

322     lap = (struct legacy_audio_policy *)calloc(1, sizeof(*lap));  

323     if (!lap)  

324         return -ENOMEM;  

325   

326     lap->policy.set_device_connection_state = ap_set_device_connection_state;  

327     lap->policy.get_device_connection_state = ap_get_device_connection_state;  

328     lap->policy.set_phone_state = ap_set_phone_state;  

329     lap->policy.set_ringer_mode = ap_set_ringer_mode;  

330     lap->policy.set_force_use = ap_set_force_use;  

331     lap->policy.get_force_use = ap_get_force_use;  

332     lap->policy.set_can_mute_enforced_audible = ap_set_can_mute_enforced_audible;  

334     lap->policy.init_check = ap_init_check;  

335     lap->policy.get_output = ap_get_output;  

336     lap->policy.start_output = ap_start_output;  

337     lap->policy.stop_output = ap_stop_output;  

338     lap->policy.release_output = ap_release_output;  

339     lap->policy.get_input = ap_get_input;  

340     lap->policy.start_input = ap_start_input;  

341     lap->policy.stop_input = ap_stop_input;  

342     lap->policy.release_input = ap_release_input;  

343     lap->policy.init_stream_volume = ap_init_stream_volume;  

344     lap->policy.set_stream_volume_index = ap_set_stream_volume_index;  

345     lap->policy.get_stream_volume_index = ap_get_stream_volume_index;                                                                    

346     lap->policy.set_stream_volume_index_for_device = ap_set_stream_volume_index_for_device;  

347     lap->policy.get_stream_volume_index_for_device = ap_get_stream_volume_index_for_device;  

348     lap->policy.get_strategy_for_stream = ap_get_strategy_for_stream;  

349     lap->policy.get_devices_for_stream = ap_get_devices_for_stream;  

350     lap->policy.get_output_for_effect = ap_get_output_for_effect;  

351     lap->policy.register_effect = ap_register_effect;  

352     lap->policy.unregister_effect = ap_unregister_effect;  

353     lap->policy.set_effect_enabled = ap_set_effect_enabled;  

354     lap->policy.is_stream_active = ap_is_stream_active;  

355     lap->policy.dump = ap_dump;  

356   

357     lap->service = service;  

358     lap->aps_ops = aps_ops;  

359     lap->service_client =  

360         new AudioPolicyCompatClient(aps_ops, service);  

361     if (!lap->service_client) {  

362         ret = -ENOMEM;  

363         goto err_new_compat_client;  

364     }  

365   

366     lap->apm = createAudioPolicyManager(lap->service_client);  

367     if (!lap->apm) {  

368         ret = -ENOMEM;  

369         goto err_create_apm;  

370     }  

371   

372     *ap = &lap->policy;  

373     return 0;  

374   

375 err_create_apm:  

376     delete lap->service_client;  

377 err_new_compat_client:  

378     free(lap);  

379     *ap = NULL;  

380     return ret;  

381 }  

372行可知,這樣mpAudioPolicy指針就指向瞭lap->policy方法。回到前面AudioPolicyService::setStreamVolumeIndex的394行調用audio_policy_hal.cpp方法:

[cpp] 

232 static int ap_set_stream_volume_index_for_device(struct audio_policy *pol,                                                     

233                                       audio_stream_type_t stream,  

234                                       int index,  

235                                       audio_devices_t device)  

236 {  

237     struct legacy_audio_policy *lap = to_lap(pol);  

238     return lap->apm->setStreamVolumeIndex((AudioSystem::stream_type)stream,  

239                                           index,  

240                                           device);  

241 }  

237行結構體legacy_audio_policy定義:

[cpp]  

44 struct legacy_audio_policy {                                                                                                    

45     struct audio_policy policy;//即為mpAudioPolicy  

46   

47     void *service;  

48     struct audio_policy_service_ops *aps_ops;  

49     AudioPolicyCompatClient *service_client;  

50     AudioPolicyInterface *apm;  

51 };  

lap->apm的賦值在前面create_legacy_ap函數的366行,看createAudioPolicyManager,hardware/libhardware_legacy/audio/AudioPolicyManagerDefault.cpp中:

[cpp 

24 extern "C" AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)  

25 {  

26     return new AudioPolicyManagerDefault(clientInterface);                                                                             

27 }  

—–>hardware/libhardware_legacy/audio/AudioPolicyManagerDefault.h:

[cpp] 

25 class AudioPolicyManagerDefault: public AudioPolicyManagerBase  

26 {  

28 public:  

29                 AudioPolicyManagerDefault(AudioPolicyClientInterface *clientInterface)                                             

30                 : AudioPolicyManagerBase(clientInterface) {}  

31   

32         virtual ~AudioPolicyManagerDefault() {}  

33   

34 };  

看基類AudioPolicyManagerBase,hardware/libhardware_legacy/include/hardware_legacy/AudioPolicyManagerBase.h的定義,終於找到瞭setStreamVolumeIndex方法,

在AudioPolicyManagerBase.cpp中:

[cpp]  

953 status_t AudioPolicyManagerBase::setStreamVolumeIndex(AudioSystem::stream_type stream, int index, audio_devices_t device)  

956 {    

958     if ((index < mStreams[stream].mIndexMin) || (index > mStreams[stream].mIndexMax)) {    

959         return BAD_VALUE;    

960     }    

961     if (!audio_is_output_device(device)) {    

962         return BAD_VALUE;    

963     }    

965     // Force max volume if stream cannot be muted    

966     if (!mStreams[stream].mCanBeMuted) index = mStreams[stream].mIndexMax;    

971     // if device is AUDIO_DEVICE_OUT_DEFAULT set default value and    

972     // clear all device specific values    

973     if (device == AUDIO_DEVICE_OUT_DEFAULT) {    

974         mStreams[stream].mIndexCur.clear();    

975     }    

976     mStreams[stream].mIndexCur.add(device, index);    

978     // compute and apply stream volume on all outputs according to connected device    

979     status_t status = NO_ERROR;    

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

981         audio_devices_t curDevice =    

982                 getDeviceForVolume((audio_devices_t)mOutputs.valueAt(i)->device());    

983         if (device == curDevice) {    

984             status_t volStatus = checkAndSetVolume(stream, index, mOutputs.keyAt(i), curDevice);    

985             if (volStatus != NO_ERROR) {    

986                 status = volStatus;    

987             }    

988         }    

989     }    

990     return status;    

991 }    

 

 

看984行checkAndSetVolume函數:

[cpp] 

2683 status_t AudioPolicyManagerBase::checkAndSetVolume(int stream,  

2684                                                    int index,  

2685                                                    audio_io_handle_t output,  

2686                                                    audio_devices_t device,  

2687                                                    int delayMs,  

2688                                                    bool force)  

2689 {  

         ………………..  

2722             if (stream == AudioSystem::BLUETOOTH_SCO) {  

2723                 mpClientInterface->setStreamVolume(AudioSystem::VOICE_CALL, volume, output, delayMs);  

2724             }  

2725         }  

2726   

2727         mpClientInterface->setStreamVolume((AudioSystem::stream_type)stream, volume, output, delayMs);  

        ……………….  

2747 }  

這裡mpClientInterface是在AudioPolicyManagerBase構造函數中賦值的,就是create_legacy_ap函數360行AudioPolicyCompatClient,方法在AudioPolicyCompatClient.cpp:

[cpp] 

120 status_t AudioPolicyCompatClient::setStreamVolume(                                                                                   

121                                              AudioSystem::stream_type stream,  

122                                              float volume,  

123                                              audio_io_handle_t output,  

124                                              int delayMs)  

125 {  

126     return mServiceOps->set_stream_volume(mService, (audio_stream_type_t)stream,  

127                                           volume, output, delayMs);  

128 }  

這裡是在構造函數中賦值的,看AudioPolicyCompatClient.h:

[cpp]  

32 class AudioPolicyCompatClient : public AudioPolicyClientInterface {  

33 public:  

34     AudioPolicyCompatClient(struct audio_policy_service_ops *serviceOps,                                                                            

35                             void *service) :  

36             mServiceOps(serviceOps) ,   

       mService(service) {}  

從36行可知,構造時候就已經賦值瞭,所以調用的是create_legacy_ap函數312行傳進來的的型參aps_ops的set_stream_volume,它的賦值在frameworks/av/services/audioflinger/AudioPolicyService.cpp中:

[cpp] 

1538     struct audio_policy_service_ops aps_ops = {  

1539         open_output           : aps_open_output,  

1540         open_duplicate_output : aps_open_dup_output,  

1541         close_output          : aps_close_output,  

1542         suspend_output        : aps_suspend_output,  

1543         restore_output        : aps_restore_output,  

1544         open_input            : aps_open_input,  

1545         close_input           : aps_close_input,  

1546         set_stream_volume     : aps_set_stream_volume,                                                                   

1547         set_stream_output     : aps_set_stream_output,  

1548         set_parameters        : aps_set_parameters,  

1549         get_parameters        : aps_get_parameters,  

1550         start_tone            : aps_start_tone,  

1551         stop_tone             : aps_stop_tone,  

1552         set_voice_volume      : aps_set_voice_volume,  

1553         move_effects          : aps_move_effects,  

1554         load_hw_module        : aps_load_hw_module,  

1555         open_output_on_module : aps_open_output_on_module,  

1556         open_input_on_module  : aps_open_input_on_module,  

1557     };  

————>

[cpp]  

1503 static int aps_set_stream_volume(void *service, audio_stream_type_t stream,                                                        

1504                                      float volume, audio_io_handle_t output,  

1505                                      int delay_ms)  

1506 {  

1507     AudioPolicyService *audioPolicyService = (AudioPolicyService *)service;  

1508   

1509     return audioPolicyService->setStreamVolume(stream, volume, output,  

1510                                                delay_ms);  

1511 }  

這裡1507行的service即create_legacy_ap 360行傳進來的service,也就是AudioPolicyService.cpp構造函數中83行的this指針,饒瞭半天居然還是調用瞭AudioPolicyService.cpp的setStreamVolume,setStreamVolume的實現:

[cpp]  

1006 int AudioPolicyService::setStreamVolume(audio_stream_type_t stream,                               

1007                                         float volume,  

1008                                         audio_io_handle_t output,  

1009                                         int delayMs)  

1010 {  

1011     return (int)mAudioCommandThread->volumeCommand(stream, volume,  

1012                                                    output, delayMs);  

1013 }  

一看就知道是個線程之類的東西瞭,AudioCommandThread繼承瞭Thread類,看看volumeCommand的實現:

[cpp]  

800 status_t AudioPolicyService::AudioCommandThread::volumeCommand(audio_stream_type_t stream,                                

801                                                                float volume,  

802                                                                audio_io_handle_t output,  

803                                                                int delayMs)  

804 {  

805     status_t status = NO_ERROR;  

806   

807     AudioCommand *command = new AudioCommand();  

808     command->mCommand = SET_VOLUME;  

809     VolumeData *data = new VolumeData();  

810     data->mStream = stream;  

811     data->mVolume = volume;  

812     data->mIO = output;  

813     command->mParam = data;  

814     if (delayMs == 0) {  

815         command->mWaitStatus = true;  

816     } else {  

817         command->mWaitStatus = false;  

818     }  

819     Mutex::Autolock _l(mLock);  

820     insertCommand_l(command, delayMs);  

821     ALOGV("AudioCommandThread() adding set volume stream %d, volume %f, output %d",  

822             stream, volume, output);  

823     mWaitWorkCV.signal();  

824     if (command->mWaitStatus) {  

825         command->mCond.wait(mLock);  

826         status =  command->mStatus;  

827         mWaitWorkCV.signal();  

828     }  

829     return status;  

830 }  

820行insertCommand_l,加入線程隊列中,看看線程的執行函數threadLoop:

[cpp]  

bool AudioPolicyService::AudioCommandThread::threadLoop()  

{  

     681                 case SET_VOLUME: {  

     682                     VolumeData *data = (VolumeData *)command->mParam;  

     683                     ALOGV("AudioCommandThread() processing set volume stream %d, \  

     684                             volume %f, output %d", data->mStream, data->mVolume, data->mIO);  

     685                     command->mStatus = AudioSystem::setStreamVolume(data->mStream,  

     686                                                                     data->mVolume,  

     687                                                                     data->mIO);  

     688                     if (command->mWaitStatus) {  

     689                         command->mCond.signal();  

     690                         mWaitWorkCV.wait(mLock);  

     691                     }  

     692                     delete data;  

     693                     }break;  

  

}  

685行,我們又回到AudioSystem.cpp中來啦:

[cpp]  

123 status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,                                          

124         audio_io_handle_t output)  

125 {  

126     if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;  

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

128     if (af == 0) return PERMISSION_DENIED;  

129     af->setStreamVolume(stream, value, output);  

130     return NO_ERROR;  

131 }  

129行,我們終於要進入AudioFlinger.cpp中啦,先看126行,get_audio_flinger:

[cpp]  

49 const sp<IAudioFlinger>& AudioSystem::get_audio_flinger()  

50 {  

51     Mutex::Autolock _l(gLock);  

52     if (gAudioFlinger == 0) {  

53         sp<IServiceManager> sm = defaultServiceManager();  

54         sp<IBinder> binder;                                                                                                        

55         do {  

56             binder = sm->getService(String16("media.audio_flinger"));  

57             if (binder != 0)  

58                 break;  

59             ALOGW("AudioFlinger not published, waiting…");  

60             usleep(500000); // 0.5 s  

61         } while (true);  

62         if (gAudioFlingerClient == NULL) {  

63             gAudioFlingerClient = new AudioFlingerClient();  

64         } else {  

65             if (gAudioErrorCallback) {  

66                 gAudioErrorCallback(NO_ERROR);  

67             }  

68         }  

69         binder->linkToDeath(gAudioFlingerClient);  

70         gAudioFlinger = interface_cast<IAudioFlinger>(binder);  

71         gAudioFlinger->registerClient(gAudioFlingerClient);  

72     }  

73     ALOGE_IF(gAudioFlinger==0, "no AudioFlinger!?");  

74   

75     return gAudioFlinger;  

76 }  

分析完前面的binder通訊,再看這個函數的代碼,太簡單瞭!70行最終得到一個BpAudioFlinger代理,以便和BnAudioFlinger通訊,他們在IAudioFlinger.cpp中:

[cpp] 

255     virtual status_t setStreamVolume(audio_stream_type_t stream, float value,                              

256             audio_io_handle_t output)  

257     {  

258         Parcel data, reply;  

259         data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());  

260         data.writeInt32((int32_t) stream);  

261         data.writeFloat(value);  

262         data.writeInt32((int32_t) output);  

263         remote()->transact(SET_STREAM_VOLUME, data, &reply);  

264         return reply.readInt32();  

265     }  

263行,,類型為SET_STREAM_VOLUME,由於AudioFlinger繼承BnAudioFlinger,調用AudioFlinger的onTransact,但該函數還是回調BnAudioFlinger的onTransact,進入

BnAudioFlinger::onTransact函數:

[cpp]  

780         case SET_STREAM_VOLUME: {                                                                                   

781             CHECK_INTERFACE(IAudioFlinger, data, reply);  

782             int stream = data.readInt32();  

783             float volume = data.readFloat();  

784             audio_io_handle_t output = (audio_io_handle_t) data.readInt32();  

785             reply->writeInt32( setStreamVolume((audio_stream_type_t) stream, volume, output) );  

786             return NO_ERROR;  

785行,進入AudioFlinger.cpp:

[cpp]  

761 status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,  

762         audio_io_handle_t output)  

763 {  

764     // check calling permissions  

765     if (!settingsAllowed()) {  

766         return PERMISSION_DENIED;  

767     }  

769     if (uint32_t(stream) >= AUDIO_STREAM_CNT) {//定義在system/core/include/system/audio.h                          

771         return BAD_VALUE;  

772     }  

774     AutoMutex lock(mLock);  

775     PlaybackThread *thread = NULL;  

776     if (output) {  

777         thread = checkPlaybackThread_l(output);  

778         if (thread == NULL) {  

779             return BAD_VALUE;  

780         }  

781     }  

783     mStreamTypes[stream].volume = value;  

785     if (thread == NULL) {  

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

787             mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value);  

788         }  

789     } else {  

790         thread->setStreamVolume(stream, value);  

791     }  

793     return NO_ERROR;  

794 }  

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。 必填欄位標示為 *