参数broadcastPermission和scheduler都为null，而参数context是上面的函数通过调用函数getOuterContext得到的，这里它就是指向MainActivity了，因为MainActivity是继承于Context类的，因此，这里用Context类型来引用。
因为条件mPackageInfo!
=null和context!
=null都成立，而且条件scheduler==null也成立，于是就调用mMainThread.getHandler来获得一个Handler了，这个Hanlder是后面用来分发ActivityManagerService发送过的广播用的。
这里的成员变量mMainThread是一个ActivityThread实例，在前面Android应用程序启动过程源代码分析这篇文章也描述过了。
我们先来看看ActivityThread.getHandler函数的实现，然后再回过头来继续分析ContextImpl.registerReceiverInternal函数。
Step3.ActivityThread.getHandler
这个函数实现在frameworks/base/core/java/android/app/ActivityThread.java文件中：
viewplain
1.public final class ActivityThread {
2. ......
3.
4. final H mH = new H（>。
5.
6. private final class H extends Handler {
7. ......
8.
9. public void handleMessage（Message msg> {
10. ......
11.
12. switch （msg.what> {
13. ......
14. }
15.
16. ......
17. }
18.
19. ......
20.
21. }
22.
23. ......
24.
25. final Handler getHandler（> {
26. return mH。
27. }
28.
29. ......
30.
31.}
有了这个Handler之后，就可以分发消息给应用程序处理了。
再回到上一步的ContextImpl.registerReceiverInternal函数中，它通过mPackageInfo.getReceiverDispatcher函数获得一个IIntentReceiver接口对象rd，这是一个Binder对象，接下来会把它传给ActivityManagerService，ActivityManagerService在收到相应的广播时，就是通过这个Binder对象来通知MainActivity来接收的。
我们也是先来看一下mPackageInfo.getReceiverDispatcher函数的实现，然后再回过头来继续分析ContextImpl.registerReceiverInternal函数。
Step4.LoadedApk.getReceiverDispatcher
这个函数实现在frameworks/base/core/java/android/app/LoadedApk.java文件中：
viewplain
1.final class LoadedApk {
2. ......
3.
4. public IIntentReceiver getReceiverDispatcher（BroadcastReceiver r,
5. Context context, Handler handler,
6. Instrumentation instrumentation, boolean registered> {
7. synchronized （mReceivers> {
8. LoadedApk.ReceiverDispatcher rd = null。
9. HashMap map = null。
10. if （registered> {
11. map = mReceivers.get（context>。
12. if （map !
= null> {
13. rd = map.get（r>。
14. }
15. }
16. if （rd == null> {
17. rd = new ReceiverDispatcher（r, context, handler,
18. instrumentation, registered>。
19. if （registered> {
20. if （map == null> {
21. map = new HashMap（>。
22. mReceivers.put（context, map>。
23. }
24. map.put（r, rd>。
25. }
26. } else {
27. rd.validate（context, handler>。
28. }
29. return rd.getIIntentReceiver（>。
30. }
31. }
32.
33. ......
34.
35. static final class ReceiverDispatcher {
36.
37. final static class InnerReceiver extends IIntentReceiver.Stub {
38. final WeakReference mDispatcher。
39. ......
40.
41. InnerReceiver（LoadedApk.ReceiverDispatcher rd, boolean strong> {
42. mDispatcher = new WeakReference（rd>。
43. ......
44. }
45.
46. ......
47. }
48.
49. ......
50.
51. final IIntentReceiver.Stub mIIntentReceiver。
52. final Handler mActivityThread。
53.
54. ......
55.
56. ReceiverDispatcher（BroadcastReceiver receiver, Context context,
57. Handler activityThread, Instrumentation instrumentation,
58. boolean registered> {
59. ......
60.
61. mIIntentReceiver = new InnerReceiver（this, !
registered>。
62. mActivityThread = activityThread。
63.
64. ......
65. }
66.
67. ......
68.
69. IIntentReceiver getIIntentReceiver（> {
70. return mIIntentReceiver。
71. }
72.
73. }
74.
75. ......
76.
77.}
在LoadedApk.getReceiverDispatcher函数中，首先看一下参数r是不是已经有相应的ReceiverDispatcher存在了，如果有，就直接返回了，否则就新建一个ReceiverDispatcher，并且以r为Key值保在一个HashMap中，而这个HashMap以Context，这里即为MainActivity为Key值保存在LoadedApk的成员变量mReceivers中，这样，只要给定一个Activity和BroadcastReceiver，就可以查看LoadedApk里面是否已经存在相应的广播接收发布器ReceiverDispatcher了。
在新建广播接收发布器ReceiverDispatcher时，会在构造函数里面创建一个InnerReceiver实例，这是一个Binder对象，实现了IIntentReceiver接口，可以通过ReceiverDispatcher.getIIntentReceiver函数来获得，获得后就会把它传给ActivityManagerService，以便接收广播。
在ReceiverDispatcher类的构造函数中，还会把传进来的Handle类型的参数activityThread保存下来，以便后面在分发广播的时候使用。
现在，再回到ContextImpl.registerReceiverInternal函数，在获得了IIntentReceiver类型的Binder对象后，就开始要把它注册到ActivityManagerService中去了。
Step5.ActivityManagerProxy.registerReceiver
这个函数实现在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：
viewplain
1.class ActivityManagerProxy implements IActivityManager
2.{
3. ......
4.
5. public Intent registerReceiver（IApplicationThread caller,
6. IIntentReceiver receiver,
7. IntentFilter filter, String pe
升级会员 