Step 15. talkWithDriver 这个函数定义在frameworks/base/libs/binder/IPCThreadState.cpp文件中： 
        
                
  1. status_tIPCThreadState::talkWithDriver(booldoReceive)
    2.             
  2. {
    3.             
  3. ......
    4.             
    5.             
  5. binder_write_readbwr;
    6.             
    7.             
  7. //Isthereadbufferempty?
    8.             
  8. constboolneedRead=mIn.dataPosition()>=mIn.dataSize();
    9.             
    10.             
  10. //Wedon'twanttowriteanythingifwearestillreading
    11.             
  11. //fromdataleftintheinputbufferandthecaller
    12.             
  12. //hasrequestedtoreadthenextdata.
    13.             
  13. constsize_toutAvail=(!doReceive||needRead)?mOut.dataSize():0;
    14.             
    15.             
  15. bwr.write_size=outAvail;
    16.             
  16. bwr.write_buffer=(longunsignedint)mOut.data();
    17.             
    18.             
  18. //Thisiswhatwe'llread.
    19.             
  19. if(doReceive&&needRead){
    20.             
  20. bwr.read_size=mIn.dataCapacity();
    21.             
  21. bwr.read_buffer=(longunsignedint)mIn.data();
    22.             
  22. }else{
    23.             
  23. bwr.read_size=0;
    24.             
  24. }
    25.             
    26.             
  26. ......
    27.             
    28.             
  28. //Returnimmediatelyifthereisnothingtodo.
    29.             
  29. if((bwr.write_size==0)&&(bwr.read_size==0))returnNO_ERROR;
    30.             
    31.             
  31. bwr.write_consumed=0;
    32.             
  32. bwr.read_consumed=0;
    33.             
  33. status_terr;
    34.             
  34. do{
    35.             
  35. ......
    36.             
  36. #ifdefined(HAVE_ANDROID_OS)
    37.             
  37. if(ioctl(mProcess->mDriverFD,BINDER_WRITE_READ,&bwr)>=0)
    38.             
  38. err=NO_ERROR;
    39.             
  39. else
    40.             
  40. err=-errno;
    41.             
  41. #else
    42.             
  42. err=INVALID_OPERATION;
    43.             
  43. #endif
    44.             
  44. ......
    45.             
  45. }
    46.             
  46. }while(err==-EINTR);
    47.             
    48.             
  48. ....
    49.             
    50.             
  50. if(err>=NO_ERROR){
    51.             
  51. if(bwr..write_consumed>0){
    52.             
  52. if(bwr.write_consumed<(ssize_t)mOut.dataSize())
    53.             
  53. mOut.remove(0,bwr.write_consumed);
    54.             
  54. else
    55.             
  55. mOut.setDataSize(0);
    56.             
  56. }
    57.             
  57. if(bwr.read_consumed>0){
    58.             
  58. mIn.setDataSize(bwr.read_consumed);
    59.             
  59. mIn.setDataPosition(0);
    60.             
  60. }
    61.             
  61. ......
    62.             
  62. returnNO_ERROR;
    63.             
  63. }
    64.             
    65.             
  65. returnerr;
    66.             
  66. }
    67.
这个函数的具体作用可以参考 Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析 一文，它只要就是通过ioctl文件操作函数来和Binder驱动程序交互的了： [cpp] view plain copy
  1. ioctl(mProcess->mDriverFD,BINDER_WRITE_READ,&bwr)
有了这个线程池之后，我们在开发Android应用程序的时候，当我们要和其它进程中进行通信时，只要定义自己的Binder对象，然后把这个Binder对象的远程接口通过其它途径传给其它进程后，其它进程就可以通过这个Binder对象的远程接口来调用我们的应用程序进程的函数了，它不像我们在C++层实现Binder进程间通信机制的Server时，必须要手动调用IPCThreadState.joinThreadPool函数来进入一个无限循环中与Binder驱动程序交互以便获得Client端的请求，这样就实现了我们在文章开头处说的Android应用程序进程天然地支持Binder进程间通信机制。 细心的读者可能会发现，从Step 1到Step 9，都是在Android应用程序框架层运行的，而从Step 10到Step 15，都是在Android系统运行时库层运行的，这两个层次中的Binder进程间通信机制的接口一个是用Java来实现的，而别一个是用C++来实现的，这两者是如何协作的呢？这就是通过JNI层来实现的了，具体可以参考 Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码分析 一文。 回到Step 8中的RuntimeInit.zygoteInit函数中，在初始化完成Binder进程间通信机制的基础设施后，它接着就要进入进程的入口函数了。 Step 16.RuntimeInit.invokeStaticMain 这个函数定义在frameworks/base/core/java/com/android/internal/os/RuntimeInit.java文件中： 
        
                
  1. publicclassZygoteInit{
    2.             
  2. ......
    3.             
    4.             
  4. staticvoidinvokeStaticMain(ClassLoaderloader,
    5.             
  5. StringclassName,String[]argv)
    6.             
  6. throwsZygoteInit.MethodAndArgsCaller{
    7.             
  7. Class<?>cl;
    8.             
    9.             
  9. try{
    10.             
  10. cl=loader.loadClass(className);
    11.             
  11. }catch(ClassNotFoundExceptionex){
    12.             
  12. ......
    13.             
  13. }
    14.             
    15.             
  15. Methodm;
    16.             
  16. try{
    17.             
  17. m=cl.getMethod("main",newClass[]{String[].class});
    18.             
  18. }catch(NoSuchMethodExceptionex){
    19.             
  19. ......
    20.             
  20. }catch(SecurityExceptionex){
    21.             
  21. ......
    22.             
  22. }
    23.             
    24.             
  24. intmodifiers=m.getModifiers();
    25.             
  25. ......
    26.             
    27.             
  27. /*
    28.             
  28. *ThisthrowgetscaughtinZygoteInit.main(),whichresponds
    29.             
  29. *byinvokingtheexception'srun()method.Thisarrangement
    30.             
  30. *clearsupallthestackframesthatwererequiredinsetting
    31.             
  31. *uptheprocess.
    32.             
  32. */
    33.             
  33. thrownewZygoteInit.MethodAndArgsCaller(m,argv);
    34.             
  34. }
    35.             
    36.             
  36. ......
    37.             
  37. }
    38.
前面我们说过，这里传进来的参数className字符串值为"android.app.ActivityThread"，这里就通ClassLoader.loadClass函数将它加载到进程中： [java] view plain copy
  1. cl=loader.loadClass(className);
然后获得它的静态成员函数main： [java] view plain copy
  1. m=cl.getMethod("main",newClass[]{String[].class});
函数最后并没有直接调用这个静态成员函数main，而是通过抛出一个异常ZygoteInit.MethodAndArgsCaller，然后让ZygoteInit.main函数在捕获这个异常的时候再调用android.app.ActivityThread类的main函数。为什么要这样做呢？注释里面已经讲得很清楚了，它是为了清理堆栈的，这样就会让android.app.ActivityThread类的main函数觉得自己是进程的入口函数，而事实上，在执行android.app.ActivityThread类的main函数之前，已经做了大量的工作了。 我们看看ZygoteInit.main函数在捕获到这个异常的时候做了什么事： 
        
                
  1. publicclassZygoteInit{
    2.             
  2. ......
    3.             
    4.             
  4. publicstaticvoidmain(Stringargv[]){
    5.             
  5. try{
    6.             
  6. ......
    7.             
  7. }catch(MethodAndArgsCallercaller){
    8.             
  8. caller.run();
    9.             
  9. }catch(RuntimeExceptionex){
    10.             
  10. ......
    11.             
  11. }
    12.             
  12. }
    13.             
    14.             
  14. ......
    15.             
  15. }
    16.
它执行MethodAndArgsCaller的run函数： 
        
                
  1. publicclassZygoteInit{
    2.             
  2. ......
    3.             
    4.             
  4. publicstaticclassMethodAndArgsCallerextendsException
    5.             
  5. implementsRunnable{
    6.             
  6. /**methodtocall*/
    7.             
  7. privatefinalMethodmMethod;
    8.             
    9.             
  9. /**argumentarray*/
    10.             
  10. privatefinalString[]mArgs;
    11.             
    12.             
  12. publicMethodAndArgsCaller(Methodmethod,String[]args){
    13.             
  13. mMethod=method;
    14.             
  14. mArgs=args;
    15.             
  15. }
    16.             
    17.             
  17. publicvoidrun(){
    18.             
  18. try{
    19.             
  19. mMethod.invoke(null,newObject[]{mArgs});
    20.             
  20. }catch(IllegalAccessExceptionex){
    21.             
  21. ......
    22.             
  22. }catch(InvocationTargetExceptionex){
    23.             
  23. ......
    24.             
  24. }
    25.             
  25. }
    26.             
  26. }
    27.             
    28.             
  28. ......
    29.             
  29. }
    30.
这里的成员变量mMethod和mArgs都是在前面构造异常对象时传进来的，这里的mMethod就对应android.app.ActivityThread类的main函数了，于是最后就通过下面语句执行这个函数： [java] view plain copy
  1. mMethod.invoke(null,newObject[]{mArgs});
这样，android.app.ActivityThread类的main函数就被执行了。 Step 17.ActivityThread.main 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中： 
        
                
  1. publicfinalclassActivityThread{
    2.             
  2. ......
    3.             
    4.             
  4. publicstaticfinalvoidmain(String[]args){
    5.             
  5. SamplingProfilerIntegration.start();
    6.             
    7.             
  7. Process.setArgV0("<pre-initialized>");
    8.             
    9.             
  9. Looper.prepareMainLooper();
    10.             
  10. if(sMainThreadHandler==null){
    11.             
  11. sMainThreadHandler=newHandler();
    12.             
  12. }
    13.             
    14.             
  14. ActivityThreadthread=newActivityThread();
    15.             
  15. thread.attach(false);
    16.             
    17.             
  17. if(false){
    18.             
  18. Looper.myLooper().setMessageLogging(new
    19.             
  19. LogPrinter(Log.DEBUG,"ActivityThread"));
    20.             
  20. }
    21.             
  21. Looper.loop();
    22.             
    23.             
  23. if(Process.supportsProcesses()){
    24.             
  24. thrownewRuntimeException("Mainthreadloopunexpectedlyexited");
    25.             
  25. }
    26.             
    27.             
  27. thread.detach();
    28.             
  28. Stringname=(thread.mInitialApplication!=null)
    29.             
  29. ?thread.mInitialApplication.getPackageName()
    30.             
  30. :"<unknown>";
    31.             
  31. Slog.i(TAG,"Mainthreadof"+name+"isnowexiting");
    32.             
  32. }
    33.             
    34.             
  34. ......
    35.             
  35. }
    36.
从这里我们可以看出，这个函数首先会在进程中创建一个ActivityThread对象： [java] view plain copy
  1. ActivityThreadthread=newActivityThread();
然后进入消息循环中： [java] view plain copy
  1. Looper.loop();
这样，我们以后就可以在这个进程中启动Activity或者Service了。 至此，Android应用程序进程启动过程的源代码就分析完成了，它除了指定新的进程的入口函数是ActivityThread的main函数之外，还为进程内的Binder对象提供了Binder进程间通信机制的基础设施，由此可见，Binder进程间通信机制在Android系统中是何等的重要，而且是无处不在，想进一步学习Android系统的Binder进程间通信机制，请参考 Android进程间通信（IPC）机制Binder简要介绍和学习计划 一文。

更多相关文章

  1. 箭头函数的基础使用
  2. Python技巧匿名函数、回调函数和高阶函数
  3. 浅析android通过jni控制service服务程序的简易流程
  4. Android(安卓)bluetooth介绍（四）： a2dp connect流程分析
  5. Android架构分析之使用自定义硬件抽象层(HAL)模块
  6. 2011年Android(安卓)Camera学习笔记之一
  7. [置顶] Android(安卓)跨进程通信Aidl的使用及注意事项
  8. Android执行shell命令
  9. Android中OpenMax的适配层

随机推荐

  1. 神经拟态技术会与 AI 芯片形成竞争吗？
  2. 红帽高管Stephanos Bacon：基于开源社区协
  3. 换协议、改代码，Elastic 要逼开发者二选一
  4. 软件架构设计原则和模式之分层架构设计
  5. 关于大数据规模化，管理层应思考的战略及团
  6. 关于 Linux中NFS的一些笔记
  7. 意派Epub360丨有了这款H5模板，春节虎头帽
  8. JavaScript 之 Proxy
  9. vue 项目中使用websocket的正确姿势
  10. 详解Java创建线程的五种常见方式