视频录制

本篇来自 **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 视频质量等级0_{51，越大质量越差，建议18}28即可，与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