视频录制

作者: 坚持编程_lyz | 来源:发表于2017-04-26 06:14 被阅读76次

    本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:

    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:

    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:

    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:


    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:


    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:


    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]


    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:


    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:


    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法


    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:


    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:


    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法


    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:


    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法


    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)


    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java

    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:


    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法


    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:


    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:

    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:


    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java

    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:


    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:


    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:


    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:


    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:


    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]


    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),


    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:
    [图片上传中。。。(12)]
    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html本篇来自 **WizardDragon **的投稿,分享了他对于四大组件启动时一些方法的调用顺序的研究结果,并且深入源码去分析遇到的问题。文章篇幅不短,希望能对大家有所帮助。
    WizardDragon 的博客地址:
    http://blog.csdn.net/long117long

    背景

    在做一个项目时,我们想在应用最早启动时,先做一些判断,然后根据判断的结果再决定要不要对其他应用提供服务。
    对其他应用提供服务指的是,我们的应用中有 ContentProvider,第三方应用通过 call 方法调用到我们提供的 ContentProvider,ContentProvider 执行逻辑后并给调用的返回结果。当第三方应用调用我们的应用时,我们的应用存在启动和未启动的两种情况。
    刚开始,我们将判断逻辑写在了自定义的 Application 的 onCreate 方法中,但等到测试时发现了很多意想不到的情况,比如:
    逻辑判断之后的结果是不给第三方应用提供“服务”,但有时候第三方应用能够使用服务,而有时候第三方应用不能使等等的问题。
    于是我们跟踪代码,发现了 四大组件 以及 Application 的各个方法( attachBaseContext、onCreate、call 等)启动顺序,跟我们之前理解的稍稍不一样。
    在弄清楚了 四大组件 和 Application 在应用冷启动时的执行顺序后,我们才把遇到的问题彻底解决。

    验证试验

    为了测试 四大组件 和 Application 的各种方法( attachBaseContext、onCreate、call 等)被系统调用的顺序,我们创建一个简单的应用,只包含这5个组件,不考虑一个应用多进程的情况,代码分别为:


    MainApplication.java

    MainActivity.java
    [图片上传中。。。(3)]
    MainService.java
    [图片上传中。。。(4)]
    MainReceiver.java

    MainProvider.java

    在以下几个场景测试时,均已冷启动的方式启动应用。
    冷启动,指的是在系统没有创建apk这个进程时启动apk。
    注意在测试的手机上,不要让测试的应用被禁止关联启动或自启动:
    场景一,点击桌面的图标启动应用,日志如下:

    场景二,通过另外一个应用以启动Service的形式启动应用,其中启动 MainService 的代码如下:
    [图片上传中。。。(8)]
    日志如下:
    [图片上传中。。。(9)]
    场景三,应用通过接受开机广播启动的方式启动,日志如下:
    [图片上传中。。。(10)]
    场景四,其他应用调用 ContentProvider 的 call 方法启动,其中,调用 MainProvider 的 call 代码如下:
    [图片上传中。。。(11)]
    日志如下:

    结论:
    从上面四个场景可以看出:
    **1. **Application 的 attachBaseContext 方法是优先执行的;
    **2. **ContentProvider 的 onCreate 的方法比 Application 的 onCreate 的方法先执行;
    **3. **Activity、Service的 onCreate 方法以及 BroadcastReceiver 的 onReceive 方法,是在 MainApplication 的 onCreate 方法之后执行的;
    4. 调用流程为: Application 的 attachBaseContext ---> ContentProvider 的 onCreate ----> Application 的 onCreate ---> Activity、Service 等的 onCreate(Activity 和 Service 不分先后);

    问题

    问题一:****ContentProvider 的 onCreate 一定是优先于 Application 的 onCreate 执行的吗?
    为了验证这个问题,MainApplication 的代码不变,我们将 MainProvider 的 onCreate 的代码改为:
    [图片上传中。。。(13)]
    我们再在上面第四种场景上进行验证,日志如下:
    [图片上传中。。。(14)]
    问题一结论:
    确实是在 ContentProvider 的 onCreate 执行完成之后,才会执行 Application 的 onCreate 的。
    问题二:****ContentProvider中 的 call方法 是在 Application 的 onCreate 执行完之后才执行的吗?
    为了验证这个问题,我们将 MainProvider 和 MainApplication 的代码改为:
    [图片上传中。。。(15)]
    [图片上传中。。。(16)]
    我们还在第四个场景下验证,日志如下:
    [图片上传中。。。(17)]
    从日志中可以发现,Application 的 onCreate 执行时,ContentProvider 的 call方法 也在同时执行。
    问题二结论:
    Application 的 onCreate方法 和 Provider 的 call方法** 不是顺序执行,而是会同时执行**。
    问题三:****有比 Application 的 attachBaseContext方法 更早执行的方法吗?
    有,比如:Application所在类的构造方法。为了验证这个问题,将代码改为:
    [图片上传中。。。(18)]
    程序启动后,日志为:
    [图片上传中。。。(19)]
    问题三结论:
    Application 的构造方法早于 Application 的 attachBaseContext方法 调用。
    那么有没有比 Application 的构造方法还早被调用的方法呢?有,自己可以再想想哦。

    遇到的坑

    好了,我们知道 attachBaseContext 的方法在“一般情况下是最早执行的“,那么在项目中为了能”尽早“的提前初始化某些模块、功能或者参数,那么我们会把代码从 Application 的onCreate方法 提前到 attachBaseContext方法 中。嗯,一切感觉起来那么美好,直到你运行程序崩溃时...
    好吧好吧,那些“坑”终于还是来了。
    “坑”一:在 Application 的 attachBaseContext方法 中,使用了 getApplicationContext方法。
    当我发现在 attachBaseContext方法 中使用 getApplicationContext方法 返回null时,内心是崩溃。
    所以,如果在 attachBaseContext方法 中要使用 context 的话,那么使用 **this **吧,别再使用 getApplicationContext() 方法了。下文有分析为什么。
    “坑”二:这个其实不算很坑,也不会引起崩溃,但需要注意:
    在 Application 的 attachBaseContext方法 中,去调用自身的 ContentProvider,那么这个 ContentProvider 会被初始化两次,也就是说这个 ContentProvider 会被两次调用到onCreate。如果你在 ContentProvider 的 onCreate 中有一些逻辑,那么一定要检查是否会有影响。
    做一下验证,在 Application 中调用 Provider 的 call方法,并在 MainActivity 中的 onCreate方法 中调用 Provider 的 call方法,Application 的代码,Provider 的代码,Activity 的代码分别如下:
    [图片上传中。。。(20)]
    启动应用后,日志如下:
    [图片上传中。。。(21)]
    可以看到,MainProvider 的 onCreate 的方法被调用了两次(因为 MainProvider 的两次 onCreate 打印出的自身对象不一样),而在 MainActivity 中调用到 call方法 执行的类,跟 MainApplication 在 attachBaseContext方法 执行的类是同一个。

    源码分析

    好了,现象、问题和“坑”都经历了一遍,那么 为什么 会是这样呢?
    我们通过看源码,来跟踪:
    1. Application 的 attachBaseContext、ContentProvider 的 onCreate 以及 Application 的 onCreate 在源码中的调用顺序。
    2. 为什么在 Application 的 attachBaseContext 中调用 getApplicationContext 得到的是null
    先看第一个问题,我们知道Java进程的入口方法一般都是在main中,而Android为了让应用开发者不需要关心应用的创建,已经帮我们进行封装,其实应用 main方法 是在 ActivityThread.java 中的。
    我们查看 ActivityThread.java 的源码,本文以下的源码都以
    6.0.1_r10
    基础。
    a. ActivityThread.java 的 main方法:
    [图片上传中。。。(22)]
    b. ActivityThread.java 的 attach方法:
    [图片上传中。。。(23)]
    c. ActivityThread.java 的 handleBindApplication(AppBindData data)方法:
    [图片上传中。。。(24)]
    d. LoaderApk.java 的 makeApplication方法
    [图片上传中。。。(25)]
    e. Instrumentation.java的相关方法
    [图片上传中。。。(26)]
    f. Application.java 的 attach方法
    [图片上传中。。。(27)]
    g. ActivityThread.java 的 handleBindApplication方法:
    [图片上传中。。。(28)]
    h. 继续跟踪 installContentProviders 这个方法,而这个方法是会调用到 installProvider方法 中的,还是在 ActivityThread.java 中:
    [图片上传中。。。(29)]
    i. 看 ContentProvider.java 中的 attachInfo方法(frameworks/base/core/java/android/content/ContentProvider.java)
    [图片上传中。。。(30)]
    j. 关于 注释7 的 mInstrumentation.callApplicationOnCreate(app) 调用到的 Instrumentation.java 中的方法
    [图片上传中。。。(31)]
    看第二问题,为什么在我们自定义 Application 中的 attachBaseContext方法 中,调用 getApplicationContext() 为 null 呢?
    1. 跟踪 getApplicationContext() 发现是在 ContextWrapper.java 中实现的:
    [图片上传中。。。(32)]
    2. 我们看 ContextImpl 的 getApplicationContext方法:
    [图片上传中。。。(33)]
    3. mPackageInfo 是什么时候赋值的呢?我们从 ContextImpl 实例化的地方入手,在注释 5.1 之前的一行代码看到了 ContextImpl 的实例化代码,跟进代码发现,果不其然,看到了 mPackageInfo 被赋值的地方:
    [图片上传中。。。(34)]
    4. 注释b.1所在的流程 早于 注释5.4 的(在注释5.4时才调用到了Application的attachBaseContext方法),在我们自定义的Application中attachBaseContext调用getApplicationContext方法时,就到了注释b,而此时mPackageInfo是不为空的,所以会执行mPackageInfo.getApplication(),那么我们再看一下LoadedApk.java中的getApplication方法(正如前面所说,mPackageInfo是LoadedApk的实例),
    [图片上传中。。。(35)]
    [图片上传中。。。(36)]
    看到这里找到原因所在了:
    因为我们在 Application 的 attachBaseContext方法 中调用 getApplicationContext() 时, mApplication 还没有被赋值,所以返回的是空,只有把 attachBaseContext方法 执行完成后,mApplication 才会被赋值。
    附图一张:
    [图片上传中。。。(37)]

    参考

    http://androidxref.com

    http://blog.csdn.net/u011228356/article/details/45102623

    http://www.wtoutiao.com/p/1f8OfGz.html请支持原文作者 : 鸿洋
    本文由马北剑西投稿。
    马北剑西的博客地址:
    http://blog.csdn.net/mabeijianxi/

    之前还推送给过一篇:仿微信视频拍摄UI, 基于ffmpeg的视频录制编辑,可以一起学习~

    1

    概述

    本库暂时是在秒拍开源库上做的二次开发,旨在开发简单好用高效的视频录制库。本篇文档只涉及Java层次逻辑,正在业余修炼c语言与JNI相关的东西,如果有幸写第二篇文章,那时将对其做更深入的剖析,如FFmpeg编译、JNI相关代码编写。

    效果图:

    [图片上传中。。。(1)]

    功能描述:

    利用FFmpeg录制定制化的视频,并可对其定制化的压缩处理。如设置视频尺寸、设置码率、码率模式、帧率、视频质量等级、压缩速度等等,当然这些只是暂时的,后期会继续维护。

    项目地址:
    https://github.com/mabeijianxi/small-video-record.

    2

    使用方法

    1:添加依赖
    compile 'com.mabeijianxi:small-video-record:1.2.0'

    2:在manifests里面添加

    <activity android:name="mabeijianxi.camera.MediaRecorderActivity"/>

    3:在Application里面初始化小视频录制:

    [图片上传中。。。(2)]

    4:跳转录制界面:

    [图片上传中。。。(3)]

    3

    原理讲解

    基本过程就是调用系统camera与AudioRecord得到视频和音频的byte回调,然后出入配置好参数FFmpeg,结束后得到目标视频。

    (1)配置Camera参数:

    首先我们录制的视频是竖着的,所以需要旋转90°(默认是横屏录制):camera.setDisplayOrientation(90);

    然后设置显示控件:camera.setPreviewDisplay(mSurfaceHolder);

    帧率设置:这个参数是可传入的,但是每个摄像头所支持的大小是不一样的,所以你传入maxFrameRate我会再校验一遍,如果当前摄像头支持此帧率那么就使用,如果不支持那么就选择个最接近且小于它的,如果你值很小有可能还是找不到,这时就选择最小的一个,具体算法如下:

    [图片上传中。。。(4)]

    摄像头输出尺寸设置:

    通过系统API mParameters.getSupportedPreviewSizes()可以得到当前摄像头所支持的尺寸,注意这里返回的Size里面其height对应的屏幕短边,width对应的是屏幕长边,也就是说我们也要校验传入的smallVideoWidth是否支持,当然smallVideoHeight不需要校验,

    因为是小视频,我们到时候说不定还会剪切掉一部分,校验完成即可得到传入的smallVideoWidth所对应的且摄像头所支持的对应高度,把这个宽高设置上即可。常见的smallVideoWidth 有480、720、1080等等。

    具体如下:

    [图片上传中。。。(5)]

    设置采样率:

    常用格式有两种:NV21 / YV12,mParameters.setPreviewFormat(ImageFormat.NV21)

    (2)接收设备并传入FFmpeg音(音频具体可参考AudioRecorder类)视频数据:

    这里首先需要知道几个FFmpeg命令:
    -vf 可以添加滤镜,特别强大,可以旋转缩放剪切等等,我们需要用到旋转和剪切(我一直考虑需不需要用缩放的方式,因为这样可以在预览界面设置高分辨率看着清晰一些)。

    transpose,旋转,对应的值有0、1、2、3,0:逆时针旋转90°然后垂直翻转1:顺时针旋转90°,2:逆时针旋转90°,3:顺时针旋转90°然后水平翻转。

    剪切,关键字是crop,其有四个参数,分别是宽度、高度、其实剪切位置的X值与Y值,如ffmpeg -i a.mp4 -vf crop=480:360:0:0...;

    -vcodec 指定视频编解码器;

    -acodec 指定音频编解码器;

    vbr 动态码率;

    cbr 静态码率;

    -crf 视频质量等级051,越大质量越差,建议1828即可,与cbr模式不兼容;

    -preset 转码速度,快慢的优劣应该都懂的,可根据自己业务场景设置,具体有:ultrafast、superfast、veryfast、faster、fast、medium、slow、slower、veryslow、placebo;

    -i 指定输入;

    -x264opts 配置其编解码参数;

    maxrate 最大码率;

    bitrate 固定码率;

    -f 输出格式;

    -s 设置帧大小。格式为 ‘wxh’;

    -ss 指定开始时间;

    -vframes 指定多少帧;

    接着皆可在录制前配置我们的录制参数:

    [图片上传中。。。(6)]

    我们这里设置了旋转滤镜与剪切滤镜,由于我们录制竖屏视频所以旋转90°,然后剪切为我们制定的视频尺寸。当然里面还有三个get函数,分别是视频质量等级转码速度码率模式

    视频质量等级命令为-crf [size]:

    [图片上传中。。。(7)]

    转码速度命令为-preset [what]:

    [图片上传中。。。(8)]

    码率模式: 码率模式分为vbr与cbr,我在里面加了三个类AutoVBRMode、VBRMode、CBRMode,三者都可传入转码速度。如果不想管那么多那么只需传入无参的AutoVBRMode对象即可,只有AutoVBRMode模式下可以传入视频质量等级值,这个值将最大程度上控制视频质量。VBRMode模式下可以指定最大码率与额定码率。、CBRMode模式下出入一个固定码率即可。

    [图片上传中。。。(9)]

    配置好后即可开始录制,在camera的数据回调里面把数据转入底层。

    [图片上传中。。。(10)]

    (3)多段视频合并

    录制过程中我们可以暂停录制,这个可能生成n段短视频,这个我们就需要合并视频了,利用FFmpeg命令也可以轻松实现:

    [图片上传中。。。(11)]

    这里视频和音频的编解码器使用原始数据的即可,命令为-vcodec copy -acodec copy这样速度回比较快,-absf表示为匹配的流设置比特流过滤器,当然还有-vbsf,最新的指定方式是-bsf:v

    (4)进一步转码压缩

    如果没有设置 doH264Compress 参数那么将不执行以下逻辑

    [图片上传中。。。(12)]

    上面我们指定了视频编解码器为libx264,音频编解码器为libfdkaac,然后跟你个性化冲入的doH264Compress 参数进行压缩,结束后我们就得到了压缩好的视频了。

    (5)截取视频中的一帧作为封面

    [图片上传中。。。(13)]

    总结

    本库的优点是简单便捷,可控性强,后期将继续维护。

    缺点是FFmpeg优点老,后期会考虑自己编译一份,那时利用FFmpeg玩转Android视频录制与压缩(二)也就出来了,优点开始期待了,有兴趣的同学

    注意:

    编译环境请满足:targetSdkVersion<=22

    出现 java.lang.UnsatisfiedLinkError错误可以尝试在gradle.properties中添加:android.useDeprecatedNdk=true,然后在主module的build.gradle中配置ndk {abiFilters "armeabi", "armeabi-v7a"}

    欢迎到我github上指教
    https://github.com/mabeijianxi/small-video-record

    相关文章

      网友评论

        本文标题:视频录制

        本文链接:https://www.haomeiwen.com/subject/jcobzttx.html