Android应用程序启动过程源代码分析(4)-阿里云开发者社区

开发者社区> 余二五> 正文

Android应用程序启动过程源代码分析(4)

简介:
+关注继续查看
 Step 15. talkWithDriver
        这个函数定义在frameworks/base/libs/binder/IPCThreadState.cpp文件中:

  1. status_t IPCThreadState::talkWithDriver(bool doReceive)   
  2. {   
  3.     ......   
  4.    
  5.     binder_write_read bwr;   
  6.    
  7.     // Is the read buffer empty?   
  8.     const bool needRead = mIn.dataPosition() >= mIn.dataSize();   
  9.    
  10.     // We don't want to write anything if we are still reading   
  11.     // from data left in the input buffer and the caller   
  12.     // has requested to read the next data.   
  13.     const size_t outAvail = (!doReceive || needRead) ? mOut.dataSize() : 0;   
  14.    
  15.     bwr.write_size = outAvail;   
  16.     bwr.write_buffer = (long unsigned int)mOut.data();   
  17.    
  18.     // This is what we'll read.   
  19.     if (doReceive && needRead) {   
  20.         bwr.read_size = mIn.dataCapacity();   
  21.         bwr.read_buffer = (long unsigned int)mIn.data();   
  22.     } else {   
  23.         bwr.read_size = 0;   
  24.     }   
  25.    
  26.     ......   
  27.    
  28.     // Return immediately if there is nothing to do.   
  29.     if ((bwr.write_size == 0) && (bwr.read_size == 0)) return NO_ERROR;   
  30.    
  31.     bwr.write_consumed = 0;   
  32.     bwr.read_consumed = 0;   
  33.     status_t err;   
  34.     do {   
  35.         ......   
  36. #if defined(HAVE_ANDROID_OS)   
  37.         if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)   
  38.             err = NO_ERROR;   
  39.         else   
  40.             err = -errno;   
  41. #else   
  42.         err = INVALID_OPERATION;   
  43. #endif   
  44.         ......   
  45.         }   
  46.     } while (err == -EINTR);   
  47.    
  48.     ....   
  49.    
  50.     if (err >= NO_ERROR) {   
  51.         if (bwr..write_consumed > 0) {   
  52.             if (bwr.write_consumed < (ssize_t)mOut.dataSize())   
  53.                 mOut.remove(0, bwr.write_consumed);   
  54.             else   
  55.                 mOut.setDataSize(0);   
  56.         }   
  57.         if (bwr.read_consumed > 0) {   
  58.             mIn.setDataSize(bwr.read_consumed);   
  59.             mIn.setDataPosition(0);   
  60.         }   
  61.         ......   
  62.         return NO_ERROR;   
  63.     }   
  64.    
  65.     return err;   
  66. }   
        这个函数的具体作用可以参考Android系统进程间通信(IPC)机制Binder中的Server启动过程源代码分析一文,它只要就是通过ioctl文件操作函数来和Binder驱动程序交互的了:
  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. public class ZygoteInit {   
  2.     ......   
  3.    
  4.     static void invokeStaticMain(ClassLoader loader,   
  5.             String className, String[] argv)   
  6.             throws ZygoteInit.MethodAndArgsCaller {   
  7.         Class<?> cl;   
  8.    
  9.         try {   
  10.             cl = loader.loadClass(className);   
  11.         } catch (ClassNotFoundException ex) {   
  12.             ......   
  13.         }   
  14.    
  15.         Method m;   
  16.         try {   
  17.             m = cl.getMethod("main"new Class[] { String[].class });   
  18.         } catch (NoSuchMethodException ex) {   
  19.             ......   
  20.         } catch (SecurityException ex) {   
  21.             ......   
  22.         }   
  23.    
  24.         int modifiers = m.getModifiers();   
  25.         ......   
  26.    
  27.         /*  
  28.         * This throw gets caught in ZygoteInit.main(), which responds  
  29.         * by invoking the exception's run() method. This arrangement  
  30.         * clears up all the stack frames that were required in setting  
  31.         * up the process.  
  32.         */   
  33.         throw new ZygoteInit.MethodAndArgsCaller(m, argv);   
  34.     }   
  35.    
  36.     ......   
  37. }   
 前面我们说过,这里传进来的参数className字符串值为"android.app.ActivityThread",这里就通ClassLoader.loadClass函数将它加载到进程中:
[java] view plaincopy
  1. cl = loader.loadClass(className);  
        然后获得它的静态成员函数main:
[java] view plaincopy
  1. m = cl.getMethod("main"new Class[] { String[].class });  
        函数最后并没有直接调用这个静态成员函数main,而是通过抛出一个异常ZygoteInit.MethodAndArgsCaller,然后让ZygoteInit.main函数在捕获这个异常的时候再调用android.app.ActivityThread类的main函数。为什么要这样做呢?注释里面已经讲得很清楚了,它是为了清理堆栈的,这样就会让android.app.ActivityThread类的main函数觉得自己是进程的入口函数,而事实上,在执行android.app.ActivityThread类的main函数之前,已经做了大量的工作了。
 
        我们看看ZygoteInit.main函数在捕获到这个异常的时候做了什么事:

  1. public class ZygoteInit {   
  2.     ......   
  3.    
  4.     public static void main(String argv[]) {   
  5.         try {   
  6.             ......   
  7.         } catch (MethodAndArgsCaller caller) {   
  8.             caller.run();   
  9.         } catch (RuntimeException ex) {   
  10.             ......   
  11.         }   
  12.     }   
  13.    
  14.     ......   
  15. }   
 它执行MethodAndArgsCaller的run函数:

  1. public class ZygoteInit {   
  2.     ......   
  3.    
  4.     public static class MethodAndArgsCaller extends Exception   
  5.             implements Runnable {   
  6.         /** method to call */   
  7.         private final Method mMethod;   
  8.    
  9.         /** argument array */   
  10.         private final String[] mArgs;   
  11.    
  12.         public MethodAndArgsCaller(Method method, String[] args) {   
  13.             mMethod = method;   
  14.             mArgs = args;   
  15.         }   
  16.    
  17.         public void run() {   
  18.             try {   
  19.                 mMethod.invoke(nullnew Object[] { mArgs });   
  20.             } catch (IllegalAccessException ex) {   
  21.                 ......   
  22.             } catch (InvocationTargetException ex) {   
  23.                 ......   
  24.             }   
  25.         }   
  26.     }   
  27.    
  28.     ......   
  29. }   
     这里的成员变量mMethod和mArgs都是在前面构造异常对象时传进来的,这里的mMethod就对应android.app.ActivityThread类的main函数了,于是最后就通过下面语句执行这个函数:
[java] view plaincopy
  1. mMethod.invoke(nullnew Object[] { mArgs });  
        这样,android.app.ActivityThread类的main函数就被执行了。
 
        Step 17. ActivityThread.main
        这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中:

  1. public final class ActivityThread {   
  2.     ......   
  3.    
  4.     public static final void main(String[] args) {   
  5.         SamplingProfilerIntegration.start();   
  6.    
  7.         Process.setArgV0("<pre-initialized>");   
  8.    
  9.         Looper.prepareMainLooper();   
  10.         if (sMainThreadHandler == null) {   
  11.             sMainThreadHandler = new Handler();   
  12.         }   
  13.    
  14.         ActivityThread thread = new ActivityThread();   
  15.         thread.attach(false);   
  16.    
  17.         if (false) {   
  18.             Looper.myLooper().setMessageLogging(new   
  19.                 LogPrinter(Log.DEBUG, "ActivityThread"));   
  20.         }   
  21.         Looper.loop();   
  22.    
  23.         if (Process.supportsProcesses()) {   
  24.             throw new RuntimeException("Main thread loop unexpectedly exited");   
  25.         }   
  26.    
  27.         thread.detach();   
  28.         String name = (thread.mInitialApplication != null)   
  29.             ? thread.mInitialApplication.getPackageName()   
  30.             : "<unknown>";   
  31.         Slog.i(TAG, "Main thread of " + name + " is now exiting");   
  32.     }   
  33.    
  34.     ......   
  35. }   
       从这里我们可以看出,这个函数首先会在进程中创建一个ActivityThread对象:
[java] view plaincopy
  1. ActivityThread thread = new ActivityThread();  
        然后进入消息循环中:
[java] view plaincopy
  1. Looper.loop();  
        这样,我们以后就可以在这个进程中启动Activity或者Service了。
 
        至此,Android应用程序进程启动过程的源代码就分析完成了,它除了指定新的进程的入口函数是ActivityThread的main函数之外,还为进程内的Binder对象提供了Binder进程间通信机制的基础设施,由此可见,Binder进程间通信机制在Android系统中是何等的重要,而且是无处不在,想进一步学习Android系统的Binder进程间通信机制,请参考Android进程间通信(IPC)机制Binder简要介绍和学习计划一文。




本文转自 Luoshengyang 51CTO博客,原文链接:http://blog.51cto.com/shyluo/966514,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
hbase源码系列(六)HMaster启动过程
这一章是server端开始的第一章,有兴趣的朋友先去看一下hbase的架构图,我专门从网上弄下来的。
1706 0
Android M应用启动流程分析
Android M的Activity启动的完整流程
3206 0
[Android]Activity启动过程
Android系统启动加载流程: 参考图 Linux内核加载完毕 启动init进程 init进程fork出zygote进程 zygote进程在ZygoteInit.main()中进行初始化的时候fork出SystemServer进程 SystemServer进程开启的时候初始化Activit...
499 0
我要做 Android 第四弹 ps(Q:如何启动其他应用的Activity?)
一、打开第三方应用 (1) Intent intent=new Intent(); //包名 包名+类名(全路径) intent.
1246 0
源码分析Dubbo服务消费端启动流程
通过前面文章详解,我们知道Dubbo服务消费者标签dubbo:reference最终会在Spring容器中创建一个对应的ReferenceBean实例,而ReferenceBean实现了Spring生命周期接口:InitializingBean,接下来应该看一下其afterPropertiesSet方法的实现。
1459 0
[Android]Android焦点流程代码分析
以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/7286503.html 通过View的View::focusSearch进行焦点搜索对应方向上的下一个可以获取焦点的View: public View focus...
1005 0
Android系统启动过程学习
版权声明:您好,转载请留下本人博客的地址,谢谢 https://blog.csdn.net/hongbochen1223/article/details/53780960 使用 an...
770 0
+关注
13107
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载