Source code analysis broadcast operation principle

[[436974]]

Preface

There are various broadcasts in Android, such as battery usage status, phone call reception and SMS reception, which will generate a broadcast. Application developers can also monitor these broadcasts and process them according to program logic.

Today we will analyze the operating mechanism of broadcasting

1. Detailed explanation of broadcasting principle and mechanism

1. Analysis of static broadcast registration process

• Static broadcast is registered by scanning installed applications through PackageManagerService at startup;
• In the construction method of PackageManagerService, the application installation directory will be scanned, and the order is to scan the system application installation directory first and then the third-party application installation directory;

PackageManagerService.scanDirLI is the method used to scan directories:

 private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
   String[] files = dir.list();
 if (files == null ) {
 return ;
 }
 int i;
 for (i=0; i<files.length; i++) {
       File file = new File(dir, files[i]);
       if (!isPackageFilename(files[i])) {
 continue ;
 }
       PackageParser.Package pkg = scanPackageLI(file,
               flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime, null );
       if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
               mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
 file.delete () ;
 }
 }
 }
 private static final boolean isPackageFilename(String name ) {
 return   name != null && name .endsWith( ".apk" );
 }

• As you can see, it uses the File.list method to list all files with the suffix ".apk" in the directory and pass them to scanPackageLI for processing;
• And scanPackageLI(File scanFile, int parseFlags, int scanMode, long currentTime, UserHandle user) will call its overloaded method internally;

 scanPackageLI(PackageParser.Package pkg, int parseFlags, int scanMode, long currentTime, UserHandle user ):
 private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanMode, long currentTime, UserHandle user ) {
 ...
  final PackageParser.Package pkg = pp.parsePackage(scanFile,scanPath, mMetrics, parseFlags);
 ...
  PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE, currentTime, user );
 ...
 }

In this scanPackageLIl, the Package will be parsed and the BroadcastReceiver registered in AndroidManifest.xml will be saved:

 ...
 N = pkg.receivers.size ();
 r = null ;
 for (i=0; i<N; i++) {
   PackageParser.Activity a = pkg.receivers.get(i);
   a.info.processName = fixProcessName(pkg.applicationInfo.processName,
           a.info.processName, pkg.applicationInfo.uid);
   mReceivers.addActivity(a, "receiver" );
 ...
 }
 ...

Static broadcast process:

• The broadcast of system applications is registered before the broadcast of third-party applications;
• The registration order of static broadcasts of applications installed in the same directory is based on the order of apks listed in File.list;
• The order in which they are registered determines the order in which they receive broadcasts;
• Through the static broadcast registration process, we have registered the static broadcast in mReceivers of PackageManagerService;

And we can use the PackageManagerService.queryIntentReceivers method to query the static broadcast corresponding to the intent

 public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags, int userId) {
   if (!sUserManager.exists(userId)) return Collections.emptyList();
   ComponentName comp = intent.getComponent();
 if (comp == null ) {
       if (intent.getSelector() != null ) {
           intent = intent.getSelector();
           comp = intent.getComponent();
 }
 }
 if (comp != null ) {
       List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
       ActivityInfo ai = getReceiverInfo(comp, flags, userId);
 if (ai != null ) {
           ResolveInfo ri = new ResolveInfo();
           ri.activityInfo = ai;
 list.add (ri);
 }
 return list;
 }
 synchronized (mPackages) {
       String pkgName = intent.getPackage();
       if (pkgName == null ) {
 return mReceivers.queryIntent(intent, resolvedType, flags, userId);
 }
       final PackageParser.Package pkg = mPackages.get(pkgName);
 if (pkg != null ) {
 return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
 userId);
 }
 return   null ;
 }
 }

2. Dynamic broadcast registration process analysis

When we call Context.registerReceiver, we will end up calling ActivityManagerService.registerReceiver:

 public Intent registerReceiver(IApplicationThread caller, String callerPackage, IIntentReceiver receiver, IntentFilter filter, String permission, int userId) {
 ...
  ReceiverList rl = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder());
 ...
  BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, permission, callingUid, userId);
 ...
  mReceiverResolver.addFilter(bf);
 ...
 }

Therefore, you can get the dynamic broadcast corresponding to the intent through mReceiverResolver.queryIntent;

3. Analysis of the broadcast sending process

ActivityManagerNative.getDefault().broadcastIntent() is called in ContextImpl.sendBroadcast

 public void sendBroadcast(Intent intent) {
    warnIfCallingFromSystemProcess();
    String resolvedType = intent.resolveTypeIfNeeded(getContentResolver());
 try {
        intent.prepareToLeaveProcess();
        ActivityManagerNative.getDefault().broadcastIntent(
            mMainThread.getApplicationThread(), intent, resolvedType, null ,
            Activity.RESULT_OK, null , null , null , AppOpsManager.OP_NONE, false , false ,getUserId());
    } catch (RemoteException e) {
 }
 }

Actually, it calls ActivityManagerService.broadcastIntent:

 public final int broadcastIntent(IApplicationThread caller,
        Intent intent, String resolvedType, IIntentReceiver resultTo,
 int resultCode, String resultData, Bundle map,
        String requiredPermission, int appOp, boolean serialized, boolean sticky, int userId) {
    enforceNotIsolatedCaller( "broadcastIntent" );
 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, map, requiredPermission, appOp, serialized, sticky,
                callingPid, callingUid, userId);
        Binder.restoreCallingIdentity(origId);
 return res;
 }
 }

Call ActivityManagerService.broadcastIntentLocked, and the key code in broadcastIntentLocked is as follows:

 broadcastIntentLocked
 // Static broadcast
 List receivers = null ;
 // Dynamic broadcast
 List<BroadcastFilter> registeredReceivers = null ;
 if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY)
 == 0) {
 // Query static broadcast
   receivers = collectReceiverComponents(intent, resolvedType, users);
 }
 if (intent.getComponent() == null ) {
 // Query dynamic broadcast
   registeredReceivers = mReceiverResolver.queryIntent(intent,
           resolvedType, false , userId);
 }
 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,
           callerPackage, callingPid, callingUid, resolvedType, requiredPermission,
           appOp, registeredReceivers, resultTo, resultCode, resultData, map,
           ordered, sticky, false , userId);
   final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r);
 if (!replaced) {
 //Send dynamic broadcast
       queue.enqueueParallelBroadcastLocked(r);
       queue.scheduleBroadcastsLocked();
 }
   registeredReceivers = null ;
 NR = 0;
 }
 ...
 if ((receivers != null && receivers. size () > 0)
 || resultTo != null ) {
   BroadcastQueue queue = broadcastQueueForIntent(intent);
   BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp,
           callerPackage, callingPid, callingUid, resolvedType,
           requiredPermission, appOp, receivers, resultTo, resultCode,
           resultData, map, ordered, sticky, false , userId);
   boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r);
 if (!replaced) {
 //Send static broadcast
       queue.enqueueOrderedBroadcastLocked(r);
       queue.scheduleBroadcastsLocked();
 }
 }

• Dynamic broadcasting takes precedence over static broadcasting, as we can see from the code above;
• In fact, static broadcast static is queried from PackageManagerService:

 private List<ResolveInfo> collectReceiverComponents(Intent intent, String resolvedType,
 int [] users) {
 ...
    List<ResolveInfo> newReceivers = AppGlobals.getPackageManager()
                        .queryIntentReceivers(intent, resolvedType, STOCK_PM_FLAGS, user );
 ...

4. Broadcast Queue

• From ActivityManagerService.broadcastIntentLocked we can see that it does not actually send the broadcast directly to the BroadcastReceiver;
• Instead, wrap it in a BroadcastRecord and put it in the BroadcastQueue:

 BroadcastQueue queue = broadcastQueueForIntent(intent);
 BroadcastRecord r = new BroadcastRecord(queue, intent, null ,
 null , -1, -1, null , null , AppOpsManager.OP_NONE, receivers, null , 0,
 null , null , false , true , true , -1);
 queue.enqueueParallelBroadcastLocked(r);
 queue.scheduleBroadcastsLocked();
 The enqueueParallelBroadcastLocked method is used to perform broadcasts concurrently. It is very simple, just put the BroadcastRecord in mParallelBroadcasts:
 public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
    mParallelBroadcasts.add (r) ;
 }

The scheduleBroadcastsLocked method is also very simple, it sends a BROADCAST_INTENT_MSG message to mHandler:

 public void scheduleBroadcastsLocked() {
   if (mBroadcastsScheduled) {
 return ;
 }
   mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
   mBroadcastsScheduled = true ;
 }

What does mHandler do when it receives a BROADCAST_INTENT_MSG message:

 final Handler mHandler = new Handler() {
 public void handleMessage(Message msg) {
 switch (msg.what) {
 case BROADCAST_INTENT_MSG: {
               processNextBroadcast( true );
 } break;
 case BROADCAST_TIMEOUT_MSG: {
               synchronized (mService) {
                   broadcastTimeoutLocked( true );
 }
 } break;
 }
 }
 };

The processNextBroadcast method is used to obtain broadcast messages from the queue and send them to BroadcastReceiver. It has two branches: parallel processing and serial processing.

5. Parallel Processing

Dynamically registered non-ordered broadcasts use parallel processing:

 final void processNextBroadcast(boolean fromMsg) {
 synchronized(mService) {
 BroadcastRecord r;
      mService.updateCpuStats();
 if (fromMsg) {
         mBroadcastsScheduled = false ;
 }
      while (mParallelBroadcasts. size () > 0) {
         r = mParallelBroadcasts.remove(0);
         r.dispatchTime = SystemClock.uptimeMillis();
         r.dispatchClockTime = System.currentTimeMillis();
         final int N = r.receivers.size ();
 for ( int i=0; i<N; i++) {
             Object target = r.receivers.get(i);
 // Send a message to Receiver
             deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false );
 }
         addBroadcastToHistoryLocked(r);
 }
 ...
 }
 ...
 }
 private final void deliverToRegisteredReceiverLocked(BroadcastRecord r,
            BroadcastFilter filter, boolean ordered) {
 ...
 // Get the Binder of BroadcastReceiver
    r.receiver = filter.receiverList.receiver.asBinder();
 ...
 // Use the Binder mechanism to pass the message to BroadcastReceiver
    performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
                    new Intent(r.intent), r.resultCode, r.resultData,
                    r.resultExtras, r.ordered, r.initialSticky, r.userId);
 ...
 }
 void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
        Intent intent, int resultCode, String data, Bundle extras,
        boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
 ......
 //The message processing is passed to the application process through Binder, and the Handler mechanism is used inside the application process to put the message processing into the main thread
        app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
                        data, extras, ordered, sticky, sendingUser, app.repProcState);
 ......
 }
 }

6. Serial processing

Ordered broadcast and static broadcast, etc., will be passed to BroadcastQueue through enqueueOrderedBroadcastLocked:

 public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
   mOrderedBroadcasts.add (r);
 }

Then in processNextBroadcast, mOrderedBroadcasts will be specially processed;

The principle of the broadcast queue transmitting the broadcast to the Receiver is actually to put the BroadcastReceiver and the message into the BroadcastRecord, and then traverse the BroadcastRecord in the BroadcastQueue through the Handler mechanism to send the message to the BroadcastReceiver;

2. Summary of Broadcasting Process

1. Android broadcasting is divided into two aspects: broadcast sender and broadcast receiver:

• Broadcasting is a communication method between Android components. It can be used in the following scenarios:
• Message communication within the same component in the same app (between single or multiple threads);
• Message communication between different components within the same app (single process);
• The same app has message communication between different components of multiple processes;
• Message communication between components of different apps;
• Message communication between the Android system and the App under certain circumstances;

2. Implementation principle

From the implementation principle point of view, broadcast in Android uses the observer mode, which is based on the publish/subscribe event model of messages. Therefore, from the implementation point of view, broadcast in Android decouples the sender and receiver of broadcast to a great extent, making the system easier to integrate and expand. The specific implementation process is roughly summarized as follows:

• The broadcast receiver BroadcastReceiver registers with AMS (Activity Manager Service) through the Binder mechanism;
• The broadcast sender sends broadcasts to AMS through the binder mechanism;
• AMS searches for a BroadcastReceiver that meets the corresponding conditions (IntentFilter/Permission, etc.) and sends the broadcast to the corresponding message loop queue of the BroadcastReceiver;
• After the message loop queue receives this broadcast, it calls back the onReceive() method in BroadcastReceiver;
• The broadcast sender and broadcast receiver belong to the message publishing and subscription ends in the observer mode respectively, and AMS belongs to the processing center in the middle;
• The execution of the broadcast sender and the broadcast receiver is asynchronous. The broadcast sent out does not care whether there is a receiver to receive it, nor does it determine when the receiver can receive it.

Summarize

Learning is like sailing against the current, if you don’t move forward, you will fall behind. The mind is like a horse running on a plain, it is easy to let go but hard to take back;

This article is reproduced from the WeChat public account "Android Development Programming"