devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 深入理解 ANR 触发原理：Broadcast_mpendingbroadcast

作者：码创造者 | 2024-08-16 20:21:05

赞

踩

mpendingbroadcast

三、BroadcastReceiver Timeout

3.1 processNextBroadcastLocked

在学习Broadcast timeout 之前最好对广播的发生流程有一定了解，可以参考gityuan大神《Android Broadcast广播机制分析》。在广播流程有基础后，我们再来看最关键的代码块processNextBroadcastLocked，我们同样提两个问题：1.broadcast 什么情况下会ANR ？ 2.ANR会有哪些log。

  1.  final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
  2.         BroadcastRecord r;
  3.  
  4.         if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "processNextBroadcast ["
  5.                 + mQueueName + "]: "
  6.                 + mParallelBroadcasts.size() + " parallel broadcasts; "
  7.                 + mDispatcher.describeStateLocked());
  8.  
  9.         mService.updateCpuStats();//更新cpu状态
  10.    //fromMsg是指processNextBroadcast()是否由BroadcastHandler所调用的. 第一次从sendBroadcast是true。
  11.         if (fromMsg) {
  12.             mBroadcastsScheduled = false;
  13.         }
  14.  
  15.         // First, deliver any non-serialized broadcasts right away.
  16. 		//part1: 处理并行广播，并行广播没有ANR的问题。
  17.         while (mParallelBroadcasts.size() > 0) {
  18.             r = mParallelBroadcasts.remove(0);//获取广播。
  19.             r.dispatchTime = SystemClock.uptimeMillis();
  20.             r.dispatchClockTime = System.currentTimeMillis();
  21.  
  22.             if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
  23.                 Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
  24.                     createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
  25.                     System.identityHashCode(r));
  26.                 Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
  27.                     createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
  28.                     System.identityHashCode(r));
  29.             }
  30.  
  31.             final int N = r.receivers.size();
  32.             if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing parallel broadcast ["
  33.                     + mQueueName + "] " + r);
  34.             for (int i=0; i<N; i++) {
  35.                 Object target = r.receivers.get(i);
  36.                 if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
  37.                         "Delivering non-ordered on [" + mQueueName + "] to registered "
  38.                         + target + ": " + r);
  39. 						//分发广播给已注册的receive
  40.                 deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
  41.             }
  42.             addBroadcastToHistoryLocked(r);//将广播添加历史统计
  43.             if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Done with parallel broadcast ["
  44.                     + mQueueName + "] " + r);
  45.         }
  46. 		
  47. 		
  48.  
  49.         // Now take care of the next serialized one...
  50.  
  51.         // If we are waiting for a process to come up to handle the next
  52.         // broadcast, then do nothing at this point.  Just in case, we
  53.         // check that the process we're waiting for still exists.
  54. 		//mPendingBroadcast 表示的是等待进程启动来处理的广播，如果进程存活则直接 return 继续等待
  55.     //如果该进程已经被杀，则重置 mPendingBroadcast 为空
  56.         if (mPendingBroadcast != null) {
  57.             if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
  58.                     "processNextBroadcast [" + mQueueName + "]: waiting for "
  59.                     + mPendingBroadcast.curApp);
  60.  
  61.             boolean isDead;
  62.             if (mPendingBroadcast.curApp.pid > 0) {
  63.                 synchronized (mService.mPidsSelfLocked) {
  64.                     ProcessRecord proc = mService.mPidsSelfLocked.get(
  65.                             mPendingBroadcast.curApp.pid);
  66.                     isDead = proc == null || proc.isCrashing();
  67.                 }
  68.             } else {
  69.                 final ProcessRecord proc = mService.mProcessList.mProcessNames.get(
  70.                         mPendingBroadcast.curApp.processName, mPendingBroadcast.curApp.uid);
  71.                 isDead = proc == null || !proc.pendingStart;
  72.             }
  73.             if (!isDead) {
  74.                 // It's still alive, so keep waiting
  75.                 return;
  76.             } else {
  77.                 Slog.w(TAG, "pending app  ["
  78.                         + mQueueName + "]" + mPendingBroadcast.curApp
  79.                         + " died before responding to broadcast");
  80.                 mPendingBroadcast.state = BroadcastRecord.IDLE;
  81.                 mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;
  82.                 mPendingBroadcast = null;
  83.             }
  84.         }
  85.  
  86.         boolean looped = false;
  87. 		
  88. 		
  89. // 这后面的都是处理有序广播
  90.         do {
  91.             final long now = SystemClock.uptimeMillis();
  92.             r = mDispatcher.getNextBroadcastLocked(now);//从有序广播list中取出一个广播。
  93.  
  94.             if (r == null) {//如果是空的话，说明没有广播需要处理，就返回。
  95.                 // No more broadcasts are deliverable right now, so all done!
  96.                 mDispatcher.scheduleDeferralCheckLocked(false);
  97.                 mService.scheduleAppGcsLocked();//所有串行广播处理完成，则调度执行gc
  98.                 if (looped) {
  99.                     // If we had finished the last ordered broadcast, then
  100.                     // make sure all processes have correct oom and sched
  101.                     // adjustments.
  102.                     mService.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_START_RECEIVER);
  103.                 }
  104.  
  105.                 // when we have no more ordered broadcast on this queue, stop logging
  106.                 if (mService.mUserController.mBootCompleted && mLogLatencyMetrics) {
  107.                     mLogLatencyMetrics = false;
  108.                 }
  109.  
  110.                 return;
  111.             }
  112.  
  113.             boolean forceReceive = false;
  114.  
  115.             // Ensure that even if something goes awry with the timeout
  116.             // detection, we catch "hung" broadcasts here, discard them,
  117.             // and continue to make progress.
  118.             //
  119.             // This is only done if the system is ready so that early-stage receivers
  120.             // don't get executed with timeouts; and of course other timeout-
  121.             // exempt broadcasts are ignored.
  122. 			//如果广播处理的总时间超过2 * mConstants.TIMEOUT * numReceivers ,broadcastTimeoutLocked 也就ANR.
  123. 			//所以在处理有序广播的时候不仅对单个广播时长有做限制，对于总的Receivers时间也有限制。
  124.             int numReceivers = (r.receivers != null) ? r.receivers.size() : 0;
  125.             if (mService.mProcessesReady && !r.timeoutExempt && r.dispatchTime > 0) {
  126.                 if ((numReceivers > 0) &&
  127.                         (now > r.dispatchTime + (2 * mConstants.TIMEOUT * numReceivers)) &&
  128.                         /// M: ANR Debug Mechanism
  129.                         !mService.mAnrManager.isAnrDeferrable()) {
  130.                     Slog.w(TAG, "Hung broadcast ["
  131.                             + mQueueName + "] discarded after timeout failure:"
  132.                             + " now=" + now
  133.                             + " dispatchTime=" + r.dispatchTime
  134.                             + " startTime=" + r.receiverTime
  135.                             + " intent=" + r.intent
  136.                             + " numReceivers=" + numReceivers
  137.                             + " nextReceiver=" + r.nextReceiver
  138.                             + " state=" + r.state);
  139. 							//发送超时广播。
  140.                     broadcastTimeoutLocked(false); // forcibly finish this broadcast
  141.                     forceReceive = true;
  142.                     r.state = BroadcastRecord.IDLE;
  143.                 }
  144.             }
  145.           
  146.             if (r.state != BroadcastRecord.IDLE) {
  147.                 if (DEBUG_BROADCAST) Slog.d(TAG_BROADCAST,
  148.                         "processNextBroadcast("
  149.                         + mQueueName + ") called when not idle (state="
  150.                         + r.state + ")");
  151.                 return;
  152.             }
  153.  
  154.             // Is the current broadcast is done for any reason?
  155. 			//如果广播接收者为空、下一个接收者下标越界、广播被中止等则继续分发下一个广播 ，r.receivers 什么时候会是null，finishReceiverLocked
  156.             if (r.receivers == null || r.nextReceiver >= numReceivers
  157.                     || r.resultAbort || forceReceive) {
  158.                 // Send the final result if requested
  159.                 if (r.resultTo != null) {
  160.                     boolean sendResult = true;
  161.  
  162.                     // if this was part of a split/deferral complex, update the refcount and only
  163.                     // send the completion when we clear all of them
  164.                     if (r.splitToken != 0) {
  165.                         int newCount = mSplitRefcounts.get(r.splitToken) - 1;
  166.                         if (newCount == 0) {
  167.                             // done!  clear out this record's bookkeeping and deliver
  168.                             if (DEBUG_BROADCAST_DEFERRAL) {
  169.                                 Slog.i(TAG_BROADCAST,
  170.                                         "Sending broadcast completion for split token "
  171.                                         + r.splitToken + " : " + r.intent.getAction());
  172.                             }
  173.                             mSplitRefcounts.delete(r.splitToken);
  174.                         } else {
  175.                             // still have some split broadcast records in flight; update refcount
  176.                             // and hold off on the callback
  177.                             if (DEBUG_BROADCAST_DEFERRAL) {
  178.                                 Slog.i(TAG_BROADCAST,
  179.                                         "Result refcount now " + newCount + " for split token "
  180.                                         + r.splitToken + " : " + r.intent.getAction()
  181.                                         + " - not sending completion yet");
  182.                             }
  183.                             sendResult = false;
  184.                             mSplitRefcounts.put(r.splitToken, newCount);
  185.                         }
  186.                     }
  187.                     if (sendResult) {
  188.                         try {
  189.                             if (DEBUG_BROADCAST) {
  190.                                 Slog.i(TAG_BROADCAST, "Finishing broadcast [" + mQueueName + "] "
  191.                                         + r.intent.getAction() + " app=" + r.callerApp);
  192.                             }
  193. 							//处理广播消息消息，调用到onReceive()
  194.                             performReceiveLocked(r.callerApp, r.resultTo,
  195.                                     new Intent(r.intent), r.resultCode,
  196.                                     r.resultData, r.resultExtras, false, false, r.userId);
  197.                             // Set this to null so that the reference
  198.                             // (local and remote) isn't kept in the mBroadcastHistory.
  199.                             r.resultTo = null;
  200.                         } catch (RemoteException e) {
  201.                             r.resultTo = null;
  202.                             Slog.w(TAG, "Failure ["
  203.                                     + mQueueName + "] sending broadcast result of "
  204.                                     + r.intent, e);
  205.                         }
  206.                     }
  207.                 }
  208.  
  209.                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Cancelling BROADCAST_TIMEOUT_MSG");
  210. 				//取消BROADCAST_TIMEOUT_MSG消息
  211.                 cancelBroadcastTimeoutLocked();
  212.  
  213.                 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
  214.                         "Finished with ordered broadcast " + r);
  215.  
  216.                 // ... and on to the next...
  217.                 addBroadcastToHistoryLocked(r);//已经发过的广播添加到list
  218.                 if (r.intent.getComponent() == null && r.intent.getPackage() == null
  219.                         && (r.intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
  220.                     // This was an implicit broadcast... let's record it for posterity.
  221.                     mService.addBroadcastStatLocked(r.intent.getAction(), r.callerPackage,
  222.                             r.manifestCount, r.manifestSkipCount, r.finishTime-r.dispatchTime);
  223.                 }
  224.                 mDispatcher.retireBroadcastLocked(r);
  225.                 r = null;
  226.                 looped = true;
  227.                 continue;
  228.             }
  229.  
  230.             // Check whether the next receiver is under deferral policy, and handle that
  231.             // accordingly.  If the current broadcast was already part of deferred-delivery
  232.             // tracking, we know that it must now be deliverable as-is without re-deferral.
  233.             if (!r.deferred) {
  234.                 final int receiverUid = r.getReceiverUid(r.receivers.get(r.nextReceiver));
  235.                 if (mDispatcher.isDeferringLocked(receiverUid)) {
  236.                     if (DEBUG_BROADCAST_DEFERRAL) {
  237.                         Slog.i(TAG_BROADCAST, "Next receiver in " + r + " uid " + receiverUid
  238.                                 + " at " + r.nextReceiver + " is under deferral");
  239.                     }
  240.                     // If this is the only (remaining) receiver in the broadcast, "splitting"
  241.                     // doesn't make sense -- just defer it as-is and retire it as the
  242.                     // currently active outgoing broadcast.
  243.                     BroadcastRecord defer;
  244.                     if (r.nextReceiver + 1 == numReceivers) {
  245.                         if (DEBUG_BROADCAST_DEFERRAL) {
  246.                             Slog.i(TAG_BROADCAST, "Sole receiver of " + r
  247.                                     + " is under deferral; setting aside and proceeding");
  248.                         }
  249.                         defer = r;
  250.                         mDispatcher.retireBroadcastLocked(r);
  251.                     } else {
  252.                         // Nontrivial case; split out 'uid's receivers to a new broadcast record
  253.                         // and defer that, then loop and pick up continuing delivery of the current
  254.                         // record (now absent those receivers).
  255.  
  256.                         // The split operation is guaranteed to match at least at 'nextReceiver'
  257.                         defer = r.splitRecipientsLocked(receiverUid, r.nextReceiver);
  258.                         if (DEBUG_BROADCAST_DEFERRAL) {
  259.                             Slog.i(TAG_BROADCAST, "Post split:");
  260.                             Slog.i(TAG_BROADCAST, "Original broadcast receivers:");
  261.                             for (int i = 0; i < r.receivers.size(); i++) {
  262.                                 Slog.i(TAG_BROADCAST, "  " + r.receivers.get(i));
  263.                             }
  264.                             Slog.i(TAG_BROADCAST, "Split receivers:");
  265.                             for (int i = 0; i < defer.receivers.size(); i++) {
  266.                                 Slog.i(TAG_BROADCAST, "  " + defer.receivers.get(i));
  267.                             }
  268.                         }
  269.                         // Track completion refcount as well if relevant
  270.                         if (r.resultTo != null) {
  271.                             int token = r.splitToken;
  272.                             if (token == 0) {
  273.                                 // first split of this record; refcount for 'r' and 'deferred'
  274.                                 r.splitToken = defer.splitToken = nextSplitTokenLocked();
  275.                                 mSplitRefcounts.put(r.splitToken, 2);
  276.                                 if (DEBUG_BROADCAST_DEFERRAL) {
  277.                                     Slog.i(TAG_BROADCAST,
  278.                                             "Broadcast needs split refcount; using new token "
  279.                                             + r.splitToken);
  280.                                 }
  281.                             } else {
  282.                                 // new split from an already-refcounted situation; increment count
  283.                                 final int curCount = mSplitRefcounts.get(token);
  284.                                 if (DEBUG_BROADCAST_DEFERRAL) {
  285.                                     if (curCount == 0) {
  286.                                         Slog.wtf(TAG_BROADCAST,
  287.                                                 "Split refcount is zero with token for " + r);
  288.                                     }
  289.                                 }
  290.                                 mSplitRefcounts.put(token, curCount + 1);
  291.                                 if (DEBUG_BROADCAST_DEFERRAL) {
  292.                                     Slog.i(TAG_BROADCAST, "New split count for token " + token
  293.                                             + " is " + (curCount + 1));
  294.                                 }
  295.                             }
  296.                         }
  297.                     }
  298.                     mDispatcher.addDeferredBroadcast(receiverUid, defer);
  299.                     r = null;
  300.                     looped = true;
  301.                     continue;
  302.                 }
  303.             }
  304.         } while (r == null);
  305.  
  306.         // Get the next receiver...
  307. 		// recIdx 表示当前接收者的下标，r.nextReceiver 为下一个接收者的下标，默认为 0
  308.         int recIdx = r.nextReceiver++;
  309.  
  310.         // Keep track of when this receiver started, and make sure there
  311.         // is a timeout message pending to kill it if need be.
  312.         r.receiverTime = SystemClock.uptimeMillis();
  313.         if (recIdx == 0) {
  314.             r.dispatchTime = r.receiverTime;//设置分发时间，这个时间对timeout比较关键。
  315.             r.dispatchClockTime = System.currentTimeMillis();
  316.  
  317.             if (mLogLatencyMetrics) {
  318.                 StatsLog.write(
  319.                         StatsLog.BROADCAST_DISPATCH_LATENCY_REPORTED,
  320.                         r.dispatchClockTime - r.enqueueClockTime);
  321.             }
  322.           
  323. 		  打印一些trace 信息。一般情况是不开启打印的。eng版本才有开启。
  324.             if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
  325.                 Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
  326.                     createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
  327.                     System.identityHashCode(r));
  328.                 Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
  329.                     createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
  330.                     System.identityHashCode(r));
  331.             }
  332.             if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing ordered broadcast ["
  333.                     + mQueueName + "] " + r);
  334.         }
  335. 		//mPendingBroadcastTimeoutMessage 这个值在刚才执行cancelBroadcastTimeoutLocked 设置false。
  336.         if (! mPendingBroadcastTimeoutMessage) {
  337.             long timeoutTime = r.receiverTime + mConstants.TIMEOUT;
  338.             if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
  339.                     "Submitting BROADCAST_TIMEOUT_MSG ["
  340.                     + mQueueName + "] for " + r + " at " + timeoutTime);
  341.             setBroadcastTimeoutLocked(timeoutTime);//在10s 后发送BROADCAST_TIMEOUT_MSG 广播，最终会执行broadcastTimeoutLocked。后面有对这个方法说明。
  342.         }
  343.  
  344.         final BroadcastOptions brOptions = r.options;
  345.         final Object nextReceiver = r.receivers.get(recIdx);
  346.  
  347. //如果是动态广播
  348.         if (nextReceiver instanceof BroadcastFilter) {
  349.             // Simple case: this is a registered receiver who gets
  350.             // a direct call.
  351.             BroadcastFilter filter = (BroadcastFilter)nextReceiver;
  352.             if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
  353.                     "Delivering ordered ["
  354.                     + mQueueName + "] to registered "
  355.                     + filter + ": " + r);
  356.             deliverToRegisteredReceiverLocked(r, filter, r.ordered, recIdx);//直接执行
  357. 			//如果广播已经执行完的情况
  358.             if (r.receiver == null || !r.ordered) {
  359.                 // The receiver has already finished, so schedule to
  360.                 // process the next one.
  361.                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Quick finishing ["
  362.                         + mQueueName + "]: ordered="
  363.                         + r.ordered + " receiver=" + r.receiver);
  364.                 r.state = BroadcastRecord.IDLE;
  365.                 scheduleBroadcastsLocked();
  366.             } else {
  367.                 if (filter.receiverList != null) {
  368.                     maybeAddAllowBackgroundActivityStartsToken(filter.receiverList.app, r);
  369.                     // r is guaranteed ordered at this point, so we know finishReceiverLocked()
  370.                     // will get a callback and handle the activity start token lifecycle.
  371.                 }
  372.                 if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
  373.                     scheduleTempWhitelistLocked(filter.owningUid,
  374.                             brOptions.getTemporaryAppWhitelistDuration(), r);
  375.                 }
  376.             }
  377.             return;
  378.         }
  379.  
  380.         // Hard case: need to instantiate the receiver, possibly
  381.         // starting its application process to host it.
  382.     
  383. 	//对于静态注册的广播接收者 对各种权限进行判断处理，跟之前的并行广播类似。
  384.         ResolveInfo info =
  385.             (ResolveInfo)nextReceiver;
  386.         ComponentName component = new ComponentName(
  387.                 info.activityInfo.applicationInfo.packageName,
  388.                 info.activityInfo.name);
  389.  
  390.         boolean skip = false;
  391.         if (brOptions != null &&
  392.                 (info.activityInfo.applicationInfo.targetSdkVersion
  393.                         < brOptions.getMinManifestReceiverApiLevel() ||
  394.                 info.activityInfo.applicationInfo.targetSdkVersion
  395.                         > brOptions.getMaxManifestReceiverApiLevel())) {
  396.             skip = true;
  397.         }
  398.         if (!skip && !mService.validateAssociationAllowedLocked(r.callerPackage, r.callingUid,
  399.                 component.getPackageName(), info.activityInfo.applicationInfo.uid)) {
  400.             Slog.w(TAG, "Association not allowed: broadcasting "
  401.                     + r.intent.toString()
  402.                     + " from " + r.callerPackage + " (pid=" + r.callingPid
  403.                     + ", uid=" + r.callingUid + ") to " + component.flattenToShortString());
  404.             skip = true;
  405.         }
  406.         if (!skip) {
  407.             skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
  408.                     r.callingPid, r.resolvedType, info.activityInfo.applicationInfo.uid);
  409.             if (skip) {
  410.                 Slog.w(TAG, "Firewall blocked: broadcasting "
  411.                         + r.intent.toString()
  412.                         + " from " + r.callerPackage + " (pid=" + r.callingPid
  413.                         + ", uid=" + r.callingUid + ") to " + component.flattenToShortString());
  414.             }
  415.         }
  416.         int perm = mService.checkComponentPermission(info.activityInfo.permission,
  417.                 r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid,
  418.                 info.activityInfo.exported);
  419.         if (!skip && perm != PackageManager.PERMISSION_GRANTED) {
  420.             if (!info.activityInfo.exported) {
  421.                 Slog.w(TAG, "Permission Denial: broadcasting "
  422.                         + r.intent.toString()
  423.                         + " from " + r.callerPackage + " (pid=" + r.callingPid
  424.                         + ", uid=" + r.callingUid + ")"
  425.                         + " is not exported from uid " + info.activityInfo.applicationInfo.uid
  426.                         + " due to receiver " + component.flattenToShortString());
  427.             } else {
  428.                 Slog.w(TAG, "Permission Denial: broadcasting "
  429.                         + r.intent.toString()
  430.                         + " from " + r.callerPackage + " (pid=" + r.callingPid
  431.                         + ", uid=" + r.callingUid + ")"
  432.                         + " requires " + info.activityInfo.permission
  433.                         + " due to receiver " + component.flattenToShortString());
  434.             }
  435.             skip = true;
  436.         } else if (!skip && info.activityInfo.permission != null) {
  437.             final int opCode = AppOpsManager.permissionToOpCode(info.activityInfo.permission);
  438.             if (opCode != AppOpsManager.OP_NONE
  439.                     && mService.mAppOpsService.noteOperation(opCode, r.callingUid,
  440.                             r.callerPackage) != AppOpsManager.MODE_ALLOWED) {
  441.                 Slog.w(TAG, "Appop Denial: broadcasting "
  442.                         + r.intent.toString()
  443.                         + " from " + r.callerPackage + " (pid="
  444.                         + r.callingPid + ", uid=" + r.callingUid + ")"
  445.                         + " requires appop " + AppOpsManager.permissionToOp(
  446.                                 info.activityInfo.permission)
  447.                         + " due to registered receiver "
  448.                         + component.flattenToShortString());
  449.                 skip = true;
  450.             }
  451.         }
  452.         if (!skip && info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID &&
  453.             r.requiredPermissions != null && r.requiredPermissions.length > 0) {
  454.             for (int i = 0; i < r.requiredPermissions.length; i++) {
  455.                 String requiredPermission = r.requiredPermissions[i];
  456.                 try {
  457.                     perm = AppGlobals.getPackageManager().
  458.                             checkPermission(requiredPermission,
  459.                                     info.activityInfo.applicationInfo.packageName,
  460.                                     UserHandle
  461.                                             .getUserId(info.activityInfo.applicationInfo.uid));
  462.                 } catch (RemoteException e) {
  463.                     perm = PackageManager.PERMISSION_DENIED;
  464.                 }
  465.                 if (perm != PackageManager.PERMISSION_GRANTED) {
  466.                     Slog.w(TAG, "Permission Denial: receiving "
  467.                             + r.intent + " to "
  468.                             + component.flattenToShortString()
  469.                             + " requires " + requiredPermission
  470.                             + " due to sender " + r.callerPackage
  471.                             + " (uid " + r.callingUid + ")");
  472.                     skip = true;
  473.                     break;
  474.                 }
  475.                 int appOp = AppOpsManager.permissionToOpCode(requiredPermission);
  476.                 if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp
  477.                         && mService.mAppOpsService.noteOperation(appOp,
  478.                         info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
  479.                         != AppOpsManager.MODE_ALLOWED) {
  480.                     Slog.w(TAG, "Appop Denial: receiving "
  481.                             + r.intent + " to "
  482.                             + component.flattenToShortString()
  483.                             + " requires appop " + AppOpsManager.permissionToOp(
  484.                             requiredPermission)
  485.                             + " due to sender " + r.callerPackage
  486.                             + " (uid " + r.callingUid + ")");
  487.                     skip = true;
  488.                     break;
  489.                 }
  490.             }
  491.         }
  492.         if (!skip && r.appOp != AppOpsManager.OP_NONE
  493.                 && mService.mAppOpsService.noteOperation(r.appOp,
  494.                 info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
  495.                 != AppOpsManager.MODE_ALLOWED) {
  496.             Slog.w(TAG, "Appop Denial: receiving "
  497.                     + r.intent + " to "
  498.                     + component.flattenToShortString()
  499.                     + " requires appop " + AppOpsManager.opToName(r.appOp)
  500.                     + " due to sender " + r.callerPackage
  501.                     + " (uid " + r.callingUid + ")");
  502.             skip = true;
  503.         }
  504.         boolean isSingleton = false;
  505.         try {
  506.             isSingleton = mService.isSingleton(info.activityInfo.processName,
  507.                     info.activityInfo.applicationInfo,
  508.                     info.activityInfo.name, info.activityInfo.flags);
  509.         } catch (SecurityException e) {
  510.             Slog.w(TAG, e.getMessage());
  511.             skip = true;
  512.         }
  513.         if ((info.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {
  514.             if (ActivityManager.checkUidPermission(
  515.                     android.Manifest.permission.INTERACT_ACROSS_USERS,
  516.                     info.activityInfo.applicationInfo.uid)
  517.                             != PackageManager.PERMISSION_GRANTED) {
  518.                 Slog.w(TAG, "Permission Denial: Receiver " + component.flattenToShortString()
  519.                         + " requests FLAG_SINGLE_USER, but app does not hold "
  520.                         + android.Manifest.permission.INTERACT_ACROSS_USERS);
  521.                 skip = true;
  522.             }
  523.         }
  524.         if (!skip && info.activityInfo.applicationInfo.isInstantApp()
  525.                 && r.callingUid != info.activityInfo.applicationInfo.uid) {
  526.             Slog.w(TAG, "Instant App Denial: receiving "
  527.                     + r.intent
  528.                     + " to " + component.flattenToShortString()
  529.                     + " due to sender " + r.callerPackage
  530.                     + " (uid " + r.callingUid + ")"
  531.                     + " Instant Apps do not support manifest receivers");
  532.             skip = true;
  533.         }
  534.         if (!skip && r.callerInstantApp
  535.                 && (info.activityInfo.flags & ActivityInfo.FLAG_VISIBLE_TO_INSTANT_APP) == 0
  536.                 && r.callingUid != info.activityInfo.applicationInfo.uid) {
  537.             Slog.w(TAG, "Instant App Denial: receiving "
  538.                     + r.intent
  539.                     + " to " + component.flattenToShortString()
  540.                     + " requires receiver have visibleToInstantApps set"
  541.                     + " due to sender " + r.callerPackage
  542.                     + " (uid " + r.callingUid + ")");
  543.             skip = true;
  544.         }
  545.         if (r.curApp != null && r.curApp.isCrashing()) {
  546.             // If the target process is crashing, just skip it.
  547.             Slog.w(TAG, "Skipping deliver ordered [" + mQueueName + "] " + r
  548.                     + " to " + r.curApp + ": process crashing");
  549.             skip = true;
  550.         }
  551.         if (!skip) {
  552.             boolean isAvailable = false;
  553.             try {
  554.                 isAvailable = AppGlobals.getPackageManager().isPackageAvailable(
  555.                         info.activityInfo.packageName,
  556.                         UserHandle.getUserId(info.activityInfo.applicationInfo.uid));
  557.             } catch (Exception e) {
  558.                 // all such failures mean we skip this receiver
  559.                 Slog.w(TAG, "Exception getting recipient info for "
  560.                         + info.activityInfo.packageName, e);
  561.             }
  562.             if (!isAvailable) {
  563.                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
  564.                         "Skipping delivery to " + info.activityInfo.packageName + " / "
  565.                         + info.activityInfo.applicationInfo.uid
  566.                         + " : package no longer available");
  567.                 skip = true;
  568.             }
  569.         }
  570.  
  571.         // If permissions need a review before any of the app components can run, we drop
  572.         // the broadcast and if the calling app is in the foreground and the broadcast is
  573.         // explicit we launch the review UI passing it a pending intent to send the skipped
  574.         // broadcast.
  575.         if (!skip) {
  576.             if (!requestStartTargetPermissionsReviewIfNeededLocked(r,
  577.                     info.activityInfo.packageName, UserHandle.getUserId(
  578.                             info.activityInfo.applicationInfo.uid))) {
  579.                 skip = true;
  580.             }
  581.         }
  582.  
  583.         // This is safe to do even if we are skipping the broadcast, and we need
  584.         // this information now to evaluate whether it is going to be allowed to run.
  585.         final int receiverUid = info.activityInfo.applicationInfo.uid;
  586.         // If it's a singleton, it needs to be the same app or a special app
  587.         if (r.callingUid != Process.SYSTEM_UID && isSingleton
  588.                 && mService.isValidSingletonCall(r.callingUid, receiverUid)) {
  589.             info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0);
  590.         }
  591. 		//该receiver所对应的进程已经运行，则直接处理
  592.         String targetProcess = info.activityInfo.processName;
  593.         ProcessRecord app = mService.getProcessRecordLocked(targetProcess,
  594.                 info.activityInfo.applicationInfo.uid, false);
  595.  
  596.         if (!skip) {
  597.             final int allowed = mService.getAppStartModeLocked(
  598.                     info.activityInfo.applicationInfo.uid, info.activityInfo.packageName,
  599.                     info.activityInfo.applicationInfo.targetSdkVersion, -1, true, false, false);
  600.             if (allowed != ActivityManager.APP_START_MODE_NORMAL) {
  601.                 // We won't allow this receiver to be launched if the app has been
  602.                 // completely disabled from launches, or it was not explicitly sent
  603.                 // to it and the app is in a state that should not receive it
  604.                 // (depending on how getAppStartModeLocked has determined that).
  605.                 if (allowed == ActivityManager.APP_START_MODE_DISABLED) {
  606.                     Slog.w(TAG, "Background execution disabled: receiving "
  607.                             + r.intent + " to "
  608.                             + component.flattenToShortString());
  609.                     skip = true;
  610.                 } else if (((r.intent.getFlags()&Intent.FLAG_RECEIVER_EXCLUDE_BACKGROUND) != 0)
  611.                         || (r.intent.getComponent() == null
  612.                             && r.intent.getPackage() == null
  613.                             && ((r.intent.getFlags()
  614.                                     & Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND) == 0)
  615.                             && !isSignaturePerm(r.requiredPermissions))) {
  616.                     mService.addBackgroundCheckViolationLocked(r.intent.getAction(),
  617.                             component.getPackageName());
  618.                     Slog.w(TAG, "Background execution not allowed: receiving "
  619.                             + r.intent + " to "
  620.                             + component.flattenToShortString());
  621.                     skip = true;
  622.                 }
  623.             }
  624.         }
  625.  
  626.         if (!skip && !Intent.ACTION_SHUTDOWN.equals(r.intent.getAction())
  627.                 && !mService.mUserController
  628.                 .isUserRunning(UserHandle.getUserId(info.activityInfo.applicationInfo.uid),
  629.                         0 /* flags */)) {
  630.             skip = true;
  631.             Slog.w(TAG,
  632.                     "Skipping delivery to " + info.activityInfo.packageName + " / "
  633.                             + info.activityInfo.applicationInfo.uid + " : user is not running");
  634.         }
  635.  
  636.         /// M: DuraSpeed @{
  637.         boolean isSuppress = false;
  638.         isSuppress = mService.mAmsExt.onBeforeStartProcessForStaticReceiver(
  639.                 info.activityInfo.packageName);
  640.         if (isSuppress) {
  641.             skip = true;
  642.         }
  643.         /// @}
  644.  
  645.         /// M: For ago performance
  646.         if (!mService.mAmsExt.isComponentNeedsStart(info.activityInfo.packageName,
  647.             "static_broadcast")) {
  648.             skip = true;
  649.         }
  650.  
  651.         if (skip) {
  652.             if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
  653.                     "Skipping delivery of ordered [" + mQueueName + "] "
  654.                     + r + " for reason described above");
  655.             r.delivery[recIdx] = BroadcastRecord.DELIVERY_SKIPPED;
  656.             r.receiver = null;
  657.             r.curFilter = null;
  658.             r.state = BroadcastRecord.IDLE;
  659.             r.manifestSkipCount++;
  660.             scheduleBroadcastsLocked();
  661.             return;
  662.         }
  663.         r.manifestCount++;
  664.  
  665.         r.delivery[recIdx] = BroadcastRecord.DELIVERY_DELIVERED;
  666.         r.state = BroadcastRecord.APP_RECEIVE;
  667.         r.curComponent = component;
  668.         r.curReceiver = info.activityInfo;
  669.         if (DEBUG_MU && r.callingUid > UserHandle.PER_USER_RANGE) {
  670.             Slog.v(TAG_MU, "Updated broadcast record activity info for secondary user, "
  671.                     + info.activityInfo + ", callingUid = " + r.callingUid + ", uid = "
  672.                     + receiverUid);
  673.         }
  674.  
  675.         if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
  676.             scheduleTempWhitelistLocked(receiverUid,
  677.                     brOptions.getTemporaryAppWhitelistDuration(), r);
  678.         }
  679.  
  680.         // Broadcast is being executed, its package can't be stopped.
  681.         try {
  682.             AppGlobals.getPackageManager().setPackageStoppedState(
  683.                     r.curComponent.getPackageName(), false, r.userId);
  684.         } catch (RemoteException e) {
  685.         } catch (IllegalArgumentException e) {
  686.             Slog.w(TAG, "Failed trying to unstop package "
  687.                     + r.curComponent.getPackageName() + ": " + e);
  688.         }
  689.  
  690.         // Is this receiver's application already running?
  691.         if (app != null && app.thread != null && !app.killed) {
  692.             try {
  693.                 app.addPackage(info.activityInfo.packageName,
  694.                         info.activityInfo.applicationInfo.longVersionCode, mService.mProcessStats);
  695.                 maybeAddAllowBackgroundActivityStartsToken(app, r);
  696.                 processCurBroadcastLocked(r, app, skipOomAdj);
  697.                 return;
  698.             } catch (RemoteException e) {
  699.                 Slog.w(TAG, "Exception when sending broadcast to "
  700.                       + r.curComponent, e);
  701.             } catch (RuntimeException e) {
  702.                 Slog.wtf(TAG, "Failed sending broadcast to "
  703.                         + r.curComponent + " with " + r.intent, e);
  704.                 // If some unexpected exception happened, just skip
  705.                 // this broadcast.  At this point we are not in the call
  706.                 // from a client, so throwing an exception out from here
  707.                 // will crash the entire system instead of just whoever
  708.                 // sent the broadcast.
  709.                 logBroadcastReceiverDiscardLocked(r);
  710.                 finishReceiverLocked(r, r.resultCode, r.resultData,
  711.                         r.resultExtras, r.resultAbort, false);
  712.                 scheduleBroadcastsLocked();
  713.                 // We need to reset the state if we failed to start the receiver.
  714.                 r.state = BroadcastRecord.IDLE;
  715.                 return;
  716.             }
  717.  
  718.             // If a dead object exception was thrown -- fall through to
  719.             // restart the application.
  720.         }
  721.  
  722.         // Not running -- get it started, to be executed when the app comes up.
  723.         if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
  724.                 "Need to start app ["
  725.                 + mQueueName + "] " + targetProcess + " for broadcast " + r);
  726. 				//该receiver所对应的进程尚未启动，则创建该进程
  727.         if ((r.curApp=mService.startProcessLocked(targetProcess,
  728.                 info.activityInfo.applicationInfo, true,
  729.                 r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND,
  730.                 new HostingRecord("broadcast", r.curComponent),
  731.                 (r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0, false, false))
  732.                         == null) {
  733. 						
  734.             // Ah, this recipient is unavailable.  Finish it if necessary,
  735.             // and mark the broadcast record as ready for the next.
  736. 			
  737. 			//启动失败的情况
  738.             Slog.w(TAG, "Unable to launch app "
  739.                     + info.activityInfo.applicationInfo.packageName + "/"
  740.                     + receiverUid + " for broadcast "
  741.                     + r.intent + ": process is bad");
  742.             logBroadcastReceiverDiscardLocked(r);
  743.             finishReceiverLocked(r, r.resultCode, r.resultData,
  744.                     r.resultExtras, r.resultAbort, false);
  745.             scheduleBroadcastsLocked();
  746.             r.state = BroadcastRecord.IDLE;
  747.             return;
  748.         }
  749.  
  750.         maybeAddAllowBackgroundActivityStartsToken(r.curApp, r);
  751.         mPendingBroadcast = r;
  752.         mPendingBroadcastRecvIndex = recIdx;
  753.     }

  上面的代码很长总的可以分为两部分：1.处理并行广播的情况。2 .处理串行广播的情况，也就我们说的有序广播。 而ANR只有是有序广播的时候才会发生。

    归纳是:1.while 循环先把并行广播处理完成。

               2. 从mDispatcher.getNextBroadcastLocked 获取 BroadcastRecord实例，如果是空的话，说明没有广播需要处理，就返回。

              3.对总的 numReceivers时间进行判断，判断依据是：2 * mConstants.TIMEOUT * numReceivers 。如果超过这个时间就broadcastTimeoutLocked，产生ANR。系统不仅对单个receiver的时间有管控，总的receivers时间也有管控。

             4 . cancelBroadcastTimeoutLocked,取消超时广播，这个对广播第一个receiver来说没什么意义，主要是对第二个之后的receiver的影响。

            5. 如果是第一个receiver的话就把分发时间付给它。  if (recIdx == 0) {r.dispatchTime = r.receiverTime}。

           6 .发生一个延迟广播 setBroadcastTimeoutLocked(timeoutTime)，时间是10s ，如果超过这个时间还没有执行cancelBroadcastTimeoutLocked 。就会引发ANR。那么提个问题，什么情况下会执行cancelBroadcastTimeoutLocked 。答案是，当广播结束完会调用AMS finishReceiver方法，nextreceiver ，执行  r.queue.processNextBroadcastLocked。由回到processNextBroadcastLocked方法中，然后就会调用cancelBroadcastTimeoutLocked

       7.如果是动态广播，就比较简单，执行deliverToRegisteredReceiverLocked，静态广播 要判断各种权限问题，还需要判断广播的进程是否存在，如果不存在需要创建新的进程。

  1. public void finishReceiver(IBinder who, int resultCode, String resultData,
  2.             Bundle resultExtras, boolean resultAbort, int flags) {
  3.         if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Finish receiver: " + who);
  4.  
  5.         // Refuse possible leaked file descriptors
  6.         if (resultExtras != null && resultExtras.hasFileDescriptors()) {
  7.             throw new IllegalArgumentException("File descriptors passed in Bundle");
  8.         }
  9.  
  10.         final long origId = Binder.clearCallingIdentity();
  11.         try {
  12.             boolean doNext = false;
  13.             BroadcastRecord r;
  14.             BroadcastQueue queue;
  15.  
  16.             synchronized(this) {
  17.                 if (isOnOffloadQueue(flags)) {
  18.                     queue = mOffloadBroadcastQueue;
  19.                 } else {
  20.                     queue = (flags & Intent.FLAG_RECEIVER_FOREGROUND) != 0
  21.                             ? mFgBroadcastQueue : mBgBroadcastQueue;
  22.                 }
  23.  
  24.                 r = queue.getMatchingOrderedReceiver(who);
  25.                 if (r != null) {
  26.                     doNext = r.queue.finishReceiverLocked(r, resultCode,
  27.                         resultData, resultExtras, resultAbort, true);
  28.                 }
  29.                 if (doNext) {
  30.                     r.queue.processNextBroadcastLocked(/*fromMsg=*/ false, /*skipOomAdj=*/ true);
  31.                 }
  32.                 // updateOomAdjLocked() will be done here
  33.                 trimApplicationsLocked(OomAdjuster.OOM_ADJ_REASON_FINISH_RECEIVER);
  34.             }
  35.  
  36.         } finally {
  37.             Binder.restoreCallingIdentity(origId);
  38.         }
  39.     }

      3.2  broadcastTimeoutLocked    

      

  1.  final void broadcastTimeoutLocked(boolean fromMsg) {
  2.         if (fromMsg) {
  3.             mPendingBroadcastTimeoutMessage = false;
  4.             /// M: ANR Debug Mechanism
  5.             mService.mAnrManager.removeBroadcastMonitorMessage();
  6.         }
  7.          //有序广播已经执行结束，或者广播接受者已经finish了。
  8.         if (mDispatcher.isEmpty() || mDispatcher.getActiveBroadcastLocked() == null) {
  9.             return;
  10.         }
  11.  
  12.         long now = SystemClock.uptimeMillis();
  13.         BroadcastRecord r = mDispatcher.getActiveBroadcastLocked();
  14.         if (fromMsg) {
  15.             /// M: ANR Debug Mechanism @{
  16.             if (mService.mAnrManager.isAnrDeferrable()) {
  17.                 setBroadcastTimeoutLocked(SystemClock.uptimeMillis() + mConstants.TIMEOUT);
  18.                 return;
  19.             } /// @}
  20.             if (!mService.mProcessesReady) {
  21.                 // Only process broadcast timeouts if the system is ready; some early
  22.                 // broadcasts do heavy work setting up system facilities
  23.                 return;
  24.             }
  25.  
  26.             // If the broadcast is generally exempt from timeout tracking, we're done
  27.             if (r.timeoutExempt) {
  28.                 if (DEBUG_BROADCAST) {
  29.                     Slog.i(TAG_BROADCAST, "Broadcast timeout but it's exempt: "
  30.                             + r.intent.getAction());
  31.                 }
  32.                 return;
  33.             }
  34.  
  35.             long timeoutTime = r.receiverTime + mConstants.TIMEOUT;
  36. 			//如果现在的时间小于超时时间，说明还没有超时，就再执行setBroadcastTimeoutLocked，TIMEOUT=10s
  37.             if (timeoutTime > now) {
  38.                 // We can observe premature timeouts because we do not cancel and reset the
  39.                 // broadcast timeout message after each receiver finishes.  Instead, we set up
  40.                 // an initial timeout then kick it down the road a little further as needed
  41.                 // when it expires.
  42.                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
  43.                         "Premature timeout ["
  44.                         + mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for "
  45.                         + timeoutTime);
  46.                 setBroadcastTimeoutLocked(timeoutTime);
  47.                 return;
  48.             }
  49.         }
  50.   //已经finish  receiver ，也就是在执行 finishReceiverLocked方法时
  51.         if (r.state == BroadcastRecord.WAITING_SERVICES) {
  52.             // In this case the broadcast had already finished, but we had decided to wait
  53.             // for started services to finish as well before going on.  So if we have actually
  54.             // waited long enough time timeout the broadcast, let's give up on the whole thing
  55.             // and just move on to the next.
  56.             Slog.i(TAG, "Waited long enough for: " + (r.curComponent != null
  57.                     ? r.curComponent.flattenToShortString() : "(null)"));
  58.             r.curComponent = null;
  59.             r.state = BroadcastRecord.IDLE;
  60.             processNextBroadcast(false);
  61.             return;
  62.         }
  63.  
  64.         // If the receiver app is being debugged we quietly ignore unresponsiveness, just
  65.         // tidying up and moving on to the next broadcast without crashing or ANRing this
  66.         // app just because it's stopped at a breakpoint.
  67.         final boolean debugging = (r.curApp != null && r.curApp.isDebugging());
  68.  
  69.         Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver
  70.                 + ", started " + (now - r.receiverTime) + "ms ago");
  71.         r.receiverTime = now;
  72.         if (!debugging) {
  73.             r.anrCount++;
  74.         }
  75.  
  76.         ProcessRecord app = null;
  77.         String anrMessage = null;
  78.  
  79.         Object curReceiver;
  80.         if (r.nextReceiver > 0) {
  81.             curReceiver = r.receivers.get(r.nextReceiver-1);
  82.             r.delivery[r.nextReceiver-1] = BroadcastRecord.DELIVERY_TIMEOUT;
  83.         } else {
  84.             curReceiver = r.curReceiver;
  85.         }
  86.         Slog.w(TAG, "Receiver during timeout of " + r + " : " + curReceiver);
  87.         logBroadcastReceiverDiscardLocked(r);
  88. 		 //查询App进程
  89.         if (curReceiver != null && curReceiver instanceof BroadcastFilter) {
  90.             BroadcastFilter bf = (BroadcastFilter)curReceiver;
  91.             if (bf.receiverList.pid != 0
  92.                     && bf.receiverList.pid != ActivityManagerService.MY_PID) {
  93.                 synchronized (mService.mPidsSelfLocked) {
  94.                     app = mService.mPidsSelfLocked.get(
  95.                             bf.receiverList.pid);
  96.                 }
  97.             }
  98.         } else {
  99.             app = r.curApp;
  100.         }
  101.  
  102.         if (app != null) {//如果进程还存在没有被杀死的话创建anrMessage
  103.             anrMessage = "Broadcast of " + r.intent.toString();
  104.         }
  105.  
  106.         if (mPendingBroadcast == r) {
  107.             mPendingBroadcast = null;
  108.         }
  109.  
  110.         // Move on to the next receiver.
  111. 		//关闭receiver 启动下一个receiver
  112.         finishReceiverLocked(r, r.resultCode, r.resultData,
  113.                 r.resultExtras, r.resultAbort, false);
  114.         scheduleBroadcastsLocked();
  115.  
  116.         if (!debugging && anrMessage != null) {
  117.             // Post the ANR to the handler since we do not want to process ANRs while
  118.             // potentially holding our lock.
  119.             mHandler.post(new AppNotResponding(app, anrMessage));
  120.         }
  121.     }
  1. //向event log 里面写log,关键字是：am_broadcast_discard_app
  2.  final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) {
  3.         final int logIndex = r.nextReceiver - 1;
  4.         if (logIndex >= 0 && logIndex < r.receivers.size()) {
  5.             Object curReceiver = r.receivers.get(logIndex);
  6.             if (curReceiver instanceof BroadcastFilter) {
  7.                 BroadcastFilter bf = (BroadcastFilter) curReceiver;
  8.                 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER,
  9.                         bf.owningUserId, System.identityHashCode(r),
  10.                         r.intent.getAction(), logIndex, System.identityHashCode(bf));
  11.             } else {
  12.                 ResolveInfo ri = (ResolveInfo) curReceiver;
  13.                 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
  14.                         UserHandle.getUserId(ri.activityInfo.applicationInfo.uid),
  15.                         System.identityHashCode(r), r.intent.getAction(), logIndex, ri.toString());
  16.             }
  17.         } else {
  18.             if (logIndex < 0) Slog.w(TAG,
  19.                     "Discarding broadcast before first receiver is invoked: " + r);
  20.             EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
  21.                     -1, System.identityHashCode(r),
  22.                     r.intent.getAction(),
  23.                     r.nextReceiver,
  24.                     "NONE");
  25.         }
  26.     }

3.3  mHandler.post(new AppNotResponding(app, anrMessage))

  1.   public void run() {
  2.             mApp.appNotResponding(null, null, null, null, false, mAnnotation);
  3.         }

 mApp是ProcessRecord ，所有会调用ProcessRecord 的appNotResponding，这部分上一章有说过：深入理解 ANR 触发原理：一

 

所以对于Broadcast ANR问题算研究完毕。那么对于开始提的两个问题我们就回答了

 1.broadcast 什么情况下会ANR ？

  答：1.所属的广播必须是有序广播，并行广播不会产生ANR问题。

         2.发生有序广播，receivers>=2。如果只有一个那么也是不会产生ANR.

         3 前台超时10s，后台超时60s，如果是多个receivers 那么总的时间不能超过 2 * mConstants.TIMEOUT * numReceivers

         4.如果 有序广播是最后一个执行者，或者进程已经被杀掉。也不会产生ANR.   if (mDispatcher.isEmpty() || mDispatcher.getActiveBroadcastLocked() == null) {
            return;
        }

         5.或者在执行broadcastTimeoutLocked 方法是，receiver在执行finishReceiverLocked的方法。

 

2.ANR会有哪些log

答：1.  Slog.w(TAG, "Hung broadcast ["
                            + mQueueName + "] discarded after timeout failure:"
                            + " now=" + now
                            + " dispatchTime=" + r.dispatchTime
                            + " startTime=" + r.receiverTime
                            + " intent=" + r.intent
                            + " numReceivers=" + numReceivers
                            + " nextReceiver=" + r.nextReceiver
                            + " state=" + r.state);

  2. 在event log 里面能搜索到 am_broadcast_discard_app  ，是由logBroadcastReceiverDiscardLocked 方法得来。

 3 .Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver
                + ", started " + (now - r.receiverTime) + "ms ago");

 4.  Slog.w(TAG, "Receiver during timeout of " + r + " : " + curReceiver);

 

 5.   EventLog.writeEvent(EventLogTags.AM_ANR, userId, pid, processName, info.flags,
                    annotation); 这个log的输出在某些情况是不会输出的，用户定义了ANR的处理。还有就是另外几种情况，isShuttingDown ，isNotResponding ，isCrashing ，killedByAm，killed

   6 .生成 data/anr/文件，里面保存了一些pid的trace 信息以及cpu信息。

  7.DropBoxManager也会输出一些anr的trace信息。

  8 .如果是前台进程还会有一个AppNotRespondingDialog。
 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/989697
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号