Android系统四大组件源代码情景分析之BroadCastRecerver

于 2018-11-09 15:53:45 发布
阅读量281 收藏
点赞数
分类专栏： Android 文章标签： Android 四大组件 BroadCastReceiver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litao55555/article/details/83898935
版权

1. BroadCastRecerver用法

1.1 定义广播接收器 — 定义在public class内部，即为内部类

private IntentFilter intentFilter ;
private MyBroadcastReceiver myBroadcastReceiver ;
class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if(action.equals("com.example.administrator.readfile.Open")){   //接收打开文件的广播
            ...
        } else if(action.equals("com.example.administrator.readfile.Delete")){      //接收删除文件的广播
            ...
        }
    }
}

1.2 动态注册广播接收器 — 在onCreate函数中添加

intentFilter = new IntentFilter() ;     //动态注册广播接收器
intentFilter.addAction("com.example.administrator.readfile.Open");
intentFilter.addAction("com.example.administrator.readfile.Delete");
myBroadcastReceiver = new MyBroadcastReceiver();
registerReceiver(myBroadcastReceiver, intentFilter) ;

1.3 发送广播 — 任意位置

Intent intent = new Intent("com.example.administrator.readfile.Open");
Intent intent = new Intent("com.example.administrator.readfile.Delete");
sendBroadcast(intent);

1.4 注销广播接收器 — 在onDestroy函数中添加

unregisterReceiver(myBroadcastReceiver);

1.5 BroadCastRecerver用法总结

a. 继承BroadcastReceiver并复写onReceive方法
b. 静态注册或动态注册广播
c. sendBroadcast发送广播

2. BroadCastReceiver原理

参考：https://www.jianshu.com/p/bc5ffb349822

2.1 广播的注册 — registerReceiver

Activity,Service,Application都是ContextWrapper的子类，ContextWrapper里面有一个Context类型的成员变量mBase，当然它实际的类型是ContextImpl
上述结论分析参考装饰者模式：https://blog.csdn.net/litao55555/article/details/83868852

//intentFilter理解为广播接收器MyBroadcastReceiver能接收的广播
intentFilter = new IntentFilter() ;     //动态注册广播接收器
intentFilter.addAction("com.example.administrator.readfile.Open");
intentFilter.addAction("com.example.administrator.readfile.Delete");
myBroadcastReceiver = new MyBroadcastReceiver() ;
registerReceiver(myBroadcastReceiver, intentFilter) ;

上面为注册BroadCastReceiver的方法，接下来分析注册的原理

frameworks\base\core\java\android\content\ContextWrapper.java
public class ContextWrapper extends Context {
	public Intent registerReceiver(
        BroadcastReceiver receiver, IntentFilter filter) {
        return mBase.registerReceiver(receiver, filter);			//ContextWrapper.mBase为ContextImpl实例化对象
    }
}

frameworks\base\core\java\android\app\ContextImpl.java
class ContextImpl extends Context {
	@Override
    public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
        return registerReceiver(receiver, filter, null, null);
    }
    @Override
    public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter,
            String broadcastPermission, Handler scheduler) {
        return registerReceiverInternal(receiver, getUserId(),
                filter, broadcastPermission, scheduler, getOuterContext(), 0);
    }
    private Intent registerReceiverInternal(BroadcastReceiver receiver, int userId,
		IntentFilter filter, String broadcastPermission,		//参数receiver = myBroadcastReceiver，filter = new IntentFilter().addAction("com.example.administrator.readfile.Open");
		Handler scheduler, Context context, int flags) {
		IIntentReceiver rd = null;
		rd = new LoadedApk.ReceiverDispatcher(receiver, context, scheduler, null, true)
											.getIIntentReceiver();
		final Intent intent = ActivityManager.getService().registerReceiver(
			mMainThread.getApplicationThread(), mBasePackageName, rd, filter,
			broadcastPermission, userId, flags);
	}
}

public final class LoadedApk {
	static final class ReceiverDispatcher {
		ReceiverDispatcher(BroadcastReceiver receiver, Context context,
			Handler activityThread, Instrumentation instrumentation,
			boolean registered) {
            mIIntentReceiver = new InnerReceiver(this, !registered);		//LoadedApk.ReceiverDispatcher.mIIntentReceiver = new InnerReceiver(new ReceiverDispatcher(), false);
            mReceiver = receiver;											//LoadedApk.ReceiverDispatcher.mReceiver = receiver = myBroadcastReceiver
            mContext = context;
            mActivityThread = activityThread;
        }
        final static class InnerReceiver extends IIntentReceiver.Stub {
            final WeakReference<LoadedApk.ReceiverDispatcher> mDispatcher;
            InnerReceiver(LoadedApk.ReceiverDispatcher rd, boolean strong) {
                mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);//LoadedApk.ReceiverDispatcher.mIIntentReceiver.mDispatcher为弱指针，指向new LoadedApk.ReceiverDispatcher(...)
            }
        }
	}
}

分析rd = new LoadedApk.ReceiverDispatcher(receiver, context, scheduler, null, true).getIIntentReceiver();
public final class LoadedApk {
	static final class ReceiverDispatcher {
		IIntentReceiver getIIntentReceiver() {
            return mIIntentReceiver;
        }
	}
}
可知rd = LoadedApk.ReceiverDispatcher.mIIntentReceiver = new InnerReceiver(new ReceiverDispatcher(), false);
其中	 LoadedApk.ReceiverDispatcher.mReceiver = receiver = myBroadcastReceiver
		 LoadedApk.ReceiverDispatcher.mIIntentReceiver.mDispatcher为弱指针，指向new LoadedApk.ReceiverDispatcher(...)

分析ActivityManager.getService()
frameworks\base\core\java\android\app\ActivityManager.java
public class ActivityManager {
	private static final Singleton<IActivityManager> IActivityManagerSingleton =
		new Singleton<IActivityManager>() {
			@Override
			protected IActivityManager create() {
				final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
				final IActivityManager am = IActivityManager.Stub.asInterface(b);
				return am;
			}
		};
    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }
}
		||
		\/AIDL

分析ActivityManager.getService().registerReceiver(...)
frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    final HashMap<IBinder, ReceiverList> mRegisteredReceivers = new HashMap<>();
    final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver
            = new IntentResolver<BroadcastFilter, BroadcastFilter>() {...}
	public Intent registerReceiver(IApplicationThread caller, String callerPackage,
		IIntentReceiver receiver, IntentFilter filter, String permission, int userId, 			//receiver = rd = LoadedApk.ReceiverDispatcher.mIIntentReceiver，其中LoadedApk.ReceiverDispatcher.mIIntentReceiver.mDispatcher为弱指针，指向new LoadedApk.ReceiverDispatcher(...)
		int flags) {																			  filter = new IntentFilter().addAction("com.example.administrator.readfile.Open");
		ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder());
		if (rl == null) {
			rl = new ReceiverList(this, callerApp, callingPid, callingUid,
					userId, receiver);
			mRegisteredReceivers.put(receiver.asBinder(), rl);
		}
		BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage,
				permission, callingUid, userId, instantApp, visibleToInstantApps);
		rl.add(bf);
		mReceiverResolver.addFilter(bf);
	}
}

函数registerReceiver的参数分析：

参数分析：receiver = LoadedApk.ReceiverDispatcher.mIIntentReceiver = new InnerReceiver(new ReceiverDispatcher(), false);
					其中LoadedApk.ReceiverDispatcher.mReceiver = myBroadcastReceiver
						LoadedApk.ReceiverDispatcher.mIIntentReceiver.mDispatcher为弱指针，指向new LoadedApk.ReceiverDispatcher(...)
		  filter = intentFilter = new IntentFilter() ;     //动态注册广播接收器
				   intentFilter.addAction("com.example.administrator.readfile.Open");
				   intentFilter.addAction("com.example.administrator.readfile.Delete");

a. 分析：rl = new ReceiverList(this, callerApp, callingPid, callingUid, userId, receiver);

frameworks\base\services\core\java\com\android\server\am\ReceiverList.java
final class ReceiverList extends ArrayList<BroadcastFilter>
	implements IBinder.DeathRecipient {
	ReceiverList(ActivityManagerService _owner, ProcessRecord _app,
		int _pid, int _uid, int _userId, IIntentReceiver _receiver) {
        receiver = _receiver;
    }
}

结论：ReceiverList rl = new ReceiverList()，且ReceiverList.receiver = 参数receiver
b. 分析：BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, permission, callingUid, userId, instantApp, visibleToInstantApps);

frameworks\base\services\core\java\com\android\server\am\BroadcastFilter.java
final class BroadcastFilter extends IntentFilter {
	final ReceiverList receiverList;
	BroadcastFilter(IntentFilter _filter, ReceiverList _receiverList,
		String _packageName, String _requiredPermission, int _owningUid, int _userId,
		boolean _instantApp, boolean _visibleToInstantApp) {
        super(_filter);
        receiverList = _receiverList;
        ...
    }
}
frameworks\base\core\java\android\content\IntentFilter.java
public class IntentFilter implements Parcelable {
	private final ArrayList<String> mActions;
	public IntentFilter(IntentFilter o) {
		...
		mActions = new ArrayList<String>(o.mActions);				//将注册时IntentFilter.mActions中的广播保存到bf.mActions
	}
	public final void addAction(String action) {
        if (!mActions.contains(action)) {
            mActions.add(action.intern());
        }
    }
}

当执行intentFilter = new IntentFilter() ;     //动态注册广播接收器
	  intentFilter.addAction("com.example.administrator.readfile.Open");
	  intentFilter.addAction("com.example.administrator.readfile.Delete");
可知super(_filter);在IntentFilter的构造函数中IntentFilter.mActions记录广播接收器myBroadcastReceiver所有能接收的广播
即广播intentFilter.addAction("com.example.administrator.readfile.Open");和intentFilter.addAction("com.example.administrator.readfile.Delete");

结论：BroadcastFilter bf = new BroadcastFilter()，其中
BroadcastFilter.receiverList = rl
BroadcastFilter.mActions记录广播接收器myBroadcastReceiver所有能接收的广播
c. 分析：rl.add(bf);
ReceiverList - rl是一个ArrayList，将BroadcastFilter - bf保存到ReceiverList - rl中
d. 分析：mReceiverResolver.addFilter(bf);

frameworks\base\services\core\java\com\android\server\IntentResolver.java
public abstract class IntentResolver<F extends IntentFilter, R extends Object> {
	private final ArraySet<F> mFilters = new ArraySet<F>();
	public void addFilter(F f) {
        mFilters.add(f);
		...
    }
}

mReceiverResolver是一个IntentResolver，将BroadcastFilter - bf保存到AMS.mReceiverResolver.mFilters中

AMS.registerReceiver参数分析：

receiver = LoadedApk.ReceiverDispatcher.mIIntentReceiver = new InnerReceiver(new ReceiverDispatcher(), false);
	   其中LoadedApk.ReceiverDispatcher.mReceiver = myBroadcastReceiver
		   LoadedApk.ReceiverDispatcher.mIIntentReceiver.mDispatcher为弱指针，指向new LoadedApk.ReceiverDispatcher(...)
filter 	 = intentFilter = new IntentFilter() ;     //动态注册广播接收器
		   intentFilter.addAction("com.example.administrator.readfile.Open");
		   intentFilter.addAction("com.example.administrator.readfile.Delete");
a. ReceiverList --- rl
ReceiverList rl = new ReceiverList()，且ReceiverList.receiver = AMS.registerReceiver()参数receiver
b. BroadcastFilter --- bf
BroadcastFilter bf = new BroadcastFilter()，且BroadcastFilter.receiverList = rl
											  BroadcastFilter.mActions记录广播接收器myBroadcastReceiver所有能接收的广播
c. IntentResolver --- mReceiverResolver
AMS.mReceiverResolver.mFilters = bf

注册BroadCastReceiver总结：
a. 注册广播时会为每一个BroadCastReceiver创建一个BroadcastFilter对象，
BroadcastFilter.receiverList保存着自定义的广播接收器myBroadcastReceiver
BroadcastFilter.mActions记录广播接收器myBroadcastReceiver所有能接收的广播，即IntentFilter intentFilter = new IntentFilter();intentFilter.addAction(“com.example.administrator.readfile.Open”);
b. 将BroadcastFilter添加到AMS.mReceiverResolver.mFilters中
AMS.mReceiverResolver.mFilters是一个ArraySet

2.2 广播的发送和接收 — sendBroadcast

Intent intent = new Intent("com.example.administrator.readfile.Open");
Intent intent = new Intent("com.example.administrator.readfile.Delete");
sendBroadcast(intent);

上面为发送广播的方法，接下来分析发送的原理

frameworks\base\core\java\android\content\ContextWrapper.java
public class ContextWrapper extends Context {
	public void sendBroadcast(Intent intent) {
        mBase.sendBroadcast(intent);
    }
}

frameworks\base\core\java\android\app\ContextImpl.java
class ContextImpl extends Context {
	@Override
    public void sendBroadcast(Intent intent) {
        warnIfCallingFromSystemProcess();
        String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
        try {
            intent.prepareToLeaveProcess(this);
            ActivityManager.getService().broadcastIntent(
				mMainThread.getApplicationThread(), intent, resolvedType, null,
				Activity.RESULT_OK, null, null, null, AppOpsManager.OP_NONE, null, false, false,
				getUserId());
        } catch (RemoteException e) {
            ...
        }
    }
}

frameworks\base\core\java\android\app\ActivityManager.java
public class ActivityManager {
	private static final Singleton<IActivityManager> IActivityManagerSingleton =
		new Singleton<IActivityManager>() {
		@Override
		protected IActivityManager create() {
			final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
			final IActivityManager am = IActivityManager.Stub.asInterface(b);
			return am;
		}
	};
    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }
}
		||
		\/AIDL
frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
	implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
	public final int broadcastIntent(IApplicationThread caller,
		Intent intent, String resolvedType, IIntentReceiver resultTo,
		int resultCode, String resultData, Bundle resultExtras,
		String[] requiredPermissions, int appOp, Bundle bOptions,
		boolean serialized, boolean sticky, int userId) {
        synchronized(this) {
            intent = verifyBroadcastLocked(intent);
            final ProcessRecord callerApp = getRecordForAppLocked(caller);
            final int callingPid = Binder.getCallingPid();
            final int callingUid = Binder.getCallingUid();
            final long origId = Binder.clearCallingIdentity();
            int res = broadcastIntentLocked(callerApp,
                    callerApp != null ? callerApp.info.packageName : null,
                    intent, resolvedType, resultTo, resultCode, resultData, resultExtras,
                    requiredPermissions, appOp, bOptions, serialized, sticky,
                    callingPid, callingUid, userId);
            Binder.restoreCallingIdentity(origId);
            return res;
        }
    }
    final int broadcastIntentLocked(ProcessRecord callerApp,
            String callerPackage, Intent intent, String resolvedType,				//intent = new Intent("com.example.administrator.readfile.Open");
            IIntentReceiver resultTo, int resultCode, String resultData,
            Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions,
            boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) {
        List receivers = null;
        if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
            receivers = collectReceiverComponents(intent, resolvedType, callingUid, users);
        }
        List<BroadcastFilter> registeredReceivers = null;
        if (intent.getComponent() == null) {
            if (userId == UserHandle.USER_ALL && callingUid == SHELL_UID) {
                for (int i = 0; i < users.length; i++) {
                    List<BroadcastFilter> registeredReceiversForUser =
                            mReceiverResolver.queryIntent(intent, resolvedType, false, users[i]);
                    if (registeredReceivers == null) {
                        registeredReceivers = registeredReceiversForUser;
                    } else if (registeredReceiversForUser != null) {
                        registeredReceivers.addAll(registeredReceiversForUser);
                    }
                }
            } else {
                registeredReceivers = mReceiverResolver.queryIntent(intent, resolvedType, false, userId);			//1. 根据intent从广播解析器AMS.mReceiverResolver中查询符合条件的BroadcastFilter列表
            }																																																			 对应注册广播时将BroadcastFilter存储到AMS.mReceiverResolver中
        }
        final boolean replacePending = (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0;
        int NR = registeredReceivers != null ? registeredReceivers.size() : 0;
        if (!ordered && NR > 0) {
        		final BroadcastQueue queue = broadcastQueueForIntent(intent);
            BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,			//2. 封装成BroadcastRecord类实例，其中BroadcastRecord.queue = queue = broadcastQueueForIntent(intent)
                    callerPackage, callingPid, callingUid, callerInstantApp, resolvedType,									  BroadcastRecord.intent = intent = new Intent("com.example.administrator.readfile.Open");
                    requiredPermissions, appOp, brOptions, registeredReceivers, resultTo,									  BroadcastRecord.receivers = registeredReceivers =AMS.mReceiverResolver.queryIntent(intent, ...)
                    resultCode, resultData, resultExtras, ordered, sticky, false, userId);
            final boolean replaced = replacePending && (queue.replaceParallelBroadcastLocked(r) != null);
            if (!replaced) {
                queue.enqueueParallelBroadcastLocked(r);		//3. 把BroadcastRecord类实例添加到并发的广播序列BroadcastQueue.mParallelBroadcasts中并准备发送
                queue.scheduleBroadcastsLocked();    //4. 开始发送有序广播和无序广播
            }
            registeredReceivers = null;
            NR = 0;
        }
    }
}

frameworks\base\services\core\java\com\android\server\am\BroadcastQueue.java
public final class BroadcastQueue {
	final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>();
	public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
        mParallelBroadcasts.add(r);		    //将BroadcastRecord保存到BroadcastQueue.mParallelBroadcasts中
        enqueueBroadcastHelper(r);
    }
}

a. 调用queryIntent根据intent从广播解析器AMS.mReceiverResolver中查询符合条件的BroadcastFilter
b. 将BroadcastFilter封装成BroadcastRecord类实例，其中
BroadcastRecord.queue = queue = broadcastQueueForIntent(intent)
BroadcastRecord.intent = intent = new Intent(“com.example.administrator.readfile.Open”);
BroadcastRecord.receivers = registeredReceivers =AMS.mReceiverResolver.queryIntent(intent, …)
c. 把BroadcastRecord类实例添加到BroadcastQueue.mParallelBroadcasts中并准备发送
d. 开始调用函数scheduleBroadcastsLocked发送有序广播和无序广播

frameworks\base\services\core\java\com\android\server\am\BroadcastQueue.java
public final class BroadcastQueue {
	public void scheduleBroadcastsLocked() {
        if (mBroadcastsScheduled) {
            return;
        }
        mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
        mBroadcastsScheduled = true;
    }
    private final class BroadcastHandler extends Handler {
        public BroadcastHandler(Looper looper) {
            super(looper, null, true);
        }
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case BROADCAST_INTENT_MSG: {
                    processNextBroadcast(true);
                } break;
                ...
            }
        }
    }
    final void processNextBroadcast(boolean fromMsg) {
		BroadcastRecord r;
		while (mParallelBroadcasts.size() > 0) {		//无序广播相关
            r = mParallelBroadcasts.remove(0);							  //5. 从BroadcastQueue.mParallelBroadcasts中取出BroadcastRecord
            final int N = r.receivers.size();		//r.receivers                BroadcastRecord.queue = queue = broadcastQueueForIntent(intent)
            for (int i=0; i<N; i++) {                                            BroadcastRecord.intent = intent = new Intent("com.example.administrator.readfile.Open");
                Object target = r.receivers.get(i);                              BroadcastRecord.receivers = registeredReceivers =AMS.mReceiverResolver.queryIntent(intent, ...)
                deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);		AMS.mReceiverResolver中保存着所有注册的广播
            }                                                                                             for循环取出所有保存在AMS.mReceiverResolver中的广播接收者BroadcastFilter --- target
            addBroadcastToHistoryLocked(r);                                                               然后将保存在BroadcastRecord.intent中的广播发给target
        }
        ...
		do {											//有序广播相关
			r = mOrderedBroadcasts.get(0);
			...
			if (r.receivers == null || r.nextReceiver >= numReceivers
				|| r.resultAbort || forceReceive) {
                if (r.resultTo != null) {
                    try {
                        performReceiveLocked(r.callerApp, r.resultTo,
                            new Intent(r.intent), r.resultCode,
                            r.resultData, r.resultExtras, false, false, r.userId);
                        r.resultTo = null;
                    } catch (RemoteException e) {
                        r.resultTo = null;
                    }
                }
                mOrderedBroadcasts.remove(0);
            }
        } while (r == null);
    }
    private void deliverToRegisteredReceiverLocked(BroadcastRecord r,		//BroadcastRecord.intent - r.intent = new Intent("com.example.administrator.readfile.Open");
		BroadcastFilter filter, boolean ordered, int index) {				//BroadcastFilter.receiverList.receiver - filter.receiverList.receiver = AMS.registerReceiver()参数receiver
	   	try {
            if (filter.receiverList.app != null && filter.receiverList.app.inFullBackup) {
                if (ordered) {
                    skipReceiverLocked(r);
                }
            } else {
                performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
                        new Intent(r.intent), r.resultCode, r.resultData,
                        r.resultExtras, r.ordered, r.initialSticky, r.userId);
            }
            if (ordered) {
                r.state = BroadcastRecord.CALL_DONE_RECEIVE;
            }
        } catch (RemoteException e) {
        		...
        }
    }
    void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,					//receiver = AMS.registerReceiver()参数receiver
            Intent intent, int resultCode, String data, Bundle extras,						  intent = new Intent("com.example.administrator.readfile.Open");
            boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
        app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
                            data, extras, ordered, sticky, sendingUser, app.repProcState);
    }
}

由于app是ProcessRecord实例化对象，在ProcessRecord中成员变量thread是IApplicationThread实例化对象，所以由AIDL机制可知
调用ApplicationThread.scheduleRegisteredReceiver
		||
		\/AIDL
frameworks\base\core\java\android\app\ActivityThread.java
public final class ActivityThread {
	private class ApplicationThread extends IApplicationThread.Stub {
		public void scheduleRegisteredReceiver(IIntentReceiver receiver, Intent intent,
		int resultCode, String dataStr, Bundle extras, boolean ordered,
		boolean sticky, int sendingUser, int processState) throws RemoteException {
			updateProcessState(processState, false);
			receiver.performReceive(intent, resultCode, dataStr, extras, ordered,		//receiver = AMS.registerReceiver()参数receiver = new InnerReceiver(new ReceiverDispatcher(), false);
					sticky, sendingUser);                                                 intent = new Intent("com.example.administrator.readfile.Open");
		}
	}
}
		||
		\/AIDL
frameworks\base\core\java\android\app\LoadedApk.java
public final class LoadedApk {
	static final class ReceiverDispatcher {
		final static class InnerReceiver extends IIntentReceiver.Stub {
			@Override
            public void performReceive(Intent intent, int resultCode, String data,
                    Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
                final LoadedApk.ReceiverDispatcher rd;
                if (intent == null) {
                    ...
                } else {
                    rd = mDispatcher.get();									//获得弱指针mDispatcher指向的对象，即new LoadedApk.ReceiverDispatcher(...)
                }
                if (rd != null) {
                    rd.performReceive(intent, resultCode, data, extras,
                            ordered, sticky, sendingUser);
                } else {
                    IActivityManager mgr = ActivityManager.getService();
                    try {
                        if (extras != null) {
                            extras.setAllowFds(false);
                        }
                        mgr.finishReceiver(this, resultCode, data, extras, false, intent.getFlags());
                    } catch (RemoteException e) {
                        ...
                    }
                }
            }
        }
        public void performReceive(Intent intent, int resultCode, String data,
			Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
            final Args args = new Args(intent, resultCode, data, extras, ordered,		//构造函数设置Args.mCurIntent = intent = new Intent("com.example.administrator.readfile.Open");
                    sticky, sendingUser);
            ...
            if (intent == null || !mActivityThread.post(
            		args.getRunnable())) {
                if (mRegistered && ordered) {
                    IActivityManager mgr = ActivityManager.getService();
                    args.sendFinished(mgr);
                }
            }
        }
        final BroadcastReceiver mReceiver;		//注册广播时ReceiverDispatcher构造函数中：LoadedApk.ReceiverDispatcher.mReceiver = receiver = myBroadcastReceiver
        final class Args extends BroadcastReceiver.PendingResult {
			public final Runnable getRunnable() {
				final BroadcastReceiver receiver = mReceiver;	//receiver = myBroadcastReceiver
				final Intent intent = mCurIntent;				//intent = new Intent("com.example.administrator.readfile.Open");
				receiver.onReceive(mContext, intent);			//重点：终于回调到myBroadcastReceiver.onReceive啦！
			}
        }
    }
}

函数scheduleBroadcastsLocked最终会回调myBroadcastReceiver.onReceive

广播的发送和接收原理总结
a. 调用queryIntent根据intent从广播解析器AMS.mReceiverResolver中查询符合条件的BroadcastFilter
b. 将BroadcastFilter封装成BroadcastRecord类实例，其中
BroadcastRecord.queue = queue = broadcastQueueForIntent(intent)
BroadcastRecord.intent = intent = new Intent(“com.example.administrator.readfile.Open”);
BroadcastRecord.receivers = registeredReceivers =AMS.mReceiverResolver.queryIntent(intent, …)
c. 把BroadcastRecord类实例添加到BroadcastQueue.mParallelBroadcasts中并准备发送
d. 开始调用函数scheduleBroadcastsLocked发送有序广播和无序广播
e. 从BroadcastQueue.mParallelBroadcasts中取出BroadcastRecord
f. 从BroadcastRecord中取出receiver和intent
receiver = LoadedApk.ReceiverDispatcher.mReceiver = myBroadcastReceiver（在注册广播时ReceiverDispatcher构造函数中设置）
intent = new Intent(“com.example.administrator.readfile.Open”);
g. 调用receiver.onReceive(mContext, intent);

3. BroadCastReceiver总结

3.1 注册

每个被注册的BroadCastReceiver都对应一个BroadcastFilter对象，BroadcastFilter对象保存在AMS.mReceiverResolver中

3.2 发送和接收

根据intent从AMS.mReceiverResolver中取出符合条件的BroadcastFilter，由BroadcastFilter和intent构造BroadcastRecord并放入BroadcastQueue中，然后从BroadcastQueue中取出BroadcastRecord并解析出receiver和intent，最终回调onReceive方法

暖阳55555
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值