1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.server.am;
18 
19 import android.content.pm.IPackageManager;
20 import android.content.pm.PermissionInfo;
21 import android.os.Trace;
22 import java.io.FileDescriptor;
23 import java.io.PrintWriter;
24 import java.text.SimpleDateFormat;
25 import java.util.ArrayList;
26 import java.util.Date;
27 import java.util.Set;
28 
29 import android.app.ActivityManager;
30 import android.app.AppGlobals;
31 import android.app.AppOpsManager;
32 import android.app.BroadcastOptions;
33 import android.app.PendingIntent;
34 import android.content.ComponentName;
35 import android.content.IIntentReceiver;
36 import android.content.IIntentSender;
37 import android.content.Intent;
38 import android.content.IntentSender;
39 import android.content.pm.ActivityInfo;
40 import android.content.pm.PackageManager;
41 import android.content.pm.ResolveInfo;
42 import android.os.Bundle;
43 import android.os.Handler;
44 import android.os.IBinder;
45 import android.os.Looper;
46 import android.os.Message;
47 import android.os.Process;
48 import android.os.RemoteException;
49 import android.os.SystemClock;
50 import android.os.UserHandle;
51 import android.util.EventLog;
52 import android.util.Slog;
53 import android.util.TimeUtils;
54 
55 import static com.android.server.am.ActivityManagerDebugConfig.*;
56 
57 /**
58  * BROADCASTS
59  *
60  * We keep two broadcast queues and associated bookkeeping, one for those at
61  * foreground priority, and one for normal (background-priority) broadcasts.
62  */
63 public final class BroadcastQueue {
64     private static final String TAG = "BroadcastQueue";
65     private static final String TAG_MU = TAG + POSTFIX_MU;
66     private static final String TAG_BROADCAST = TAG + POSTFIX_BROADCAST;
67 
68     static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50;
69     static final int MAX_BROADCAST_SUMMARY_HISTORY
70             = ActivityManager.isLowRamDeviceStatic() ? 25 : 300;
71 
72     final ActivityManagerService mService;
73 
74     /**
75      * Recognizable moniker for this queue
76      */
77     final String mQueueName;
78 
79     /**
80      * Timeout period for this queue's broadcasts
81      */
82     final long mTimeoutPeriod;
83 
84     /**
85      * If true, we can delay broadcasts while waiting services to finish in the previous
86      * receiver's process.
87      */
88     final boolean mDelayBehindServices;
89 
90     /**
91      * Lists of all active broadcasts that are to be executed immediately
92      * (without waiting for another broadcast to finish).  Currently this only
93      * contains broadcasts to registered receivers, to avoid spinning up
94      * a bunch of processes to execute IntentReceiver components.  Background-
95      * and foreground-priority broadcasts are queued separately.
96      */
97     final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>();
98 
99     /**
100      * List of all active broadcasts that are to be executed one at a time.
101      * The object at the top of the list is the currently activity broadcasts;
102      * those after it are waiting for the top to finish.  As with parallel
103      * broadcasts, separate background- and foreground-priority queues are
104      * maintained.
105      */
106     final ArrayList<BroadcastRecord> mOrderedBroadcasts = new ArrayList<>();
107 
108     /**
109      * Historical data of past broadcasts, for debugging.  This is a ring buffer
110      * whose last element is at mHistoryNext.
111      */
112     final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY];
113     int mHistoryNext = 0;
114 
115     /**
116      * Summary of historical data of past broadcasts, for debugging.  This is a
117      * ring buffer whose last element is at mSummaryHistoryNext.
118      */
119     final Intent[] mBroadcastSummaryHistory = new Intent[MAX_BROADCAST_SUMMARY_HISTORY];
120     int mSummaryHistoryNext = 0;
121 
122     /**
123      * Various milestone timestamps of entries in the mBroadcastSummaryHistory ring
124      * buffer, also tracked via the mSummaryHistoryNext index.  These are all in wall
125      * clock time, not elapsed.
126      */
127     final long[] mSummaryHistoryEnqueueTime = new  long[MAX_BROADCAST_SUMMARY_HISTORY];
128     final long[] mSummaryHistoryDispatchTime = new  long[MAX_BROADCAST_SUMMARY_HISTORY];
129     final long[] mSummaryHistoryFinishTime = new  long[MAX_BROADCAST_SUMMARY_HISTORY];
130 
131     /**
132      * Set when we current have a BROADCAST_INTENT_MSG in flight.
133      */
134     boolean mBroadcastsScheduled = false;
135 
136     /**
137      * True if we have a pending unexpired BROADCAST_TIMEOUT_MSG posted to our handler.
138      */
139     boolean mPendingBroadcastTimeoutMessage;
140 
141     /**
142      * Intent broadcasts that we have tried to start, but are
143      * waiting for the application's process to be created.  We only
144      * need one per scheduling class (instead of a list) because we always
145      * process broadcasts one at a time, so no others can be started while
146      * waiting for this one.
147      */
148     BroadcastRecord mPendingBroadcast = null;
149 
150     /**
151      * The receiver index that is pending, to restart the broadcast if needed.
152      */
153     int mPendingBroadcastRecvIndex;
154 
155     static final int BROADCAST_INTENT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG;
156     static final int BROADCAST_TIMEOUT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG + 1;
157 
158     final BroadcastHandler mHandler;
159 
160     private final class BroadcastHandler extends Handler {
BroadcastHandler(Looper looper)161         public BroadcastHandler(Looper looper) {
162             super(looper, null, true);
163         }
164 
165         @Override
handleMessage(Message msg)166         public void handleMessage(Message msg) {
167             switch (msg.what) {
168                 case BROADCAST_INTENT_MSG: {
169                     if (DEBUG_BROADCAST) Slog.v(
170                             TAG_BROADCAST, "Received BROADCAST_INTENT_MSG");
171                     processNextBroadcast(true);
172                 } break;
173                 case BROADCAST_TIMEOUT_MSG: {
174                     synchronized (mService) {
175                         broadcastTimeoutLocked(true);
176                     }
177                 } break;
178             }
179         }
180     }
181 
182     private final class AppNotResponding implements Runnable {
183         private final ProcessRecord mApp;
184         private final String mAnnotation;
185 
AppNotResponding(ProcessRecord app, String annotation)186         public AppNotResponding(ProcessRecord app, String annotation) {
187             mApp = app;
188             mAnnotation = annotation;
189         }
190 
191         @Override
run()192         public void run() {
193             mService.mAppErrors.appNotResponding(mApp, null, null, false, mAnnotation);
194         }
195     }
196 
BroadcastQueue(ActivityManagerService service, Handler handler, String name, long timeoutPeriod, boolean allowDelayBehindServices)197     BroadcastQueue(ActivityManagerService service, Handler handler,
198             String name, long timeoutPeriod, boolean allowDelayBehindServices) {
199         mService = service;
200         mHandler = new BroadcastHandler(handler.getLooper());
201         mQueueName = name;
202         mTimeoutPeriod = timeoutPeriod;
203         mDelayBehindServices = allowDelayBehindServices;
204     }
205 
206     @Override
toString()207     public String toString() {
208         return mQueueName;
209     }
210 
isPendingBroadcastProcessLocked(int pid)211     public boolean isPendingBroadcastProcessLocked(int pid) {
212         return mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid;
213     }
214 
enqueueParallelBroadcastLocked(BroadcastRecord r)215     public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
216         mParallelBroadcasts.add(r);
217         enqueueBroadcastHelper(r);
218     }
219 
enqueueOrderedBroadcastLocked(BroadcastRecord r)220     public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
221         mOrderedBroadcasts.add(r);
222         enqueueBroadcastHelper(r);
223     }
224 
225     /**
226      * Don't call this method directly; call enqueueParallelBroadcastLocked or
227      * enqueueOrderedBroadcastLocked.
228      */
enqueueBroadcastHelper(BroadcastRecord r)229     private void enqueueBroadcastHelper(BroadcastRecord r) {
230         r.enqueueClockTime = System.currentTimeMillis();
231 
232         if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
233             Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
234                 createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
235                 System.identityHashCode(r));
236         }
237     }
238 
239     /**
240      * Find the same intent from queued parallel broadcast, replace with a new one and return
241      * the old one.
242      */
replaceParallelBroadcastLocked(BroadcastRecord r)243     public final BroadcastRecord replaceParallelBroadcastLocked(BroadcastRecord r) {
244         return replaceBroadcastLocked(mParallelBroadcasts, r, "PARALLEL");
245     }
246 
247     /**
248      * Find the same intent from queued ordered broadcast, replace with a new one and return
249      * the old one.
250      */
replaceOrderedBroadcastLocked(BroadcastRecord r)251     public final BroadcastRecord replaceOrderedBroadcastLocked(BroadcastRecord r) {
252         return replaceBroadcastLocked(mOrderedBroadcasts, r, "ORDERED");
253     }
254 
replaceBroadcastLocked(ArrayList<BroadcastRecord> queue, BroadcastRecord r, String typeForLogging)255     private BroadcastRecord replaceBroadcastLocked(ArrayList<BroadcastRecord> queue,
256             BroadcastRecord r, String typeForLogging) {
257         final Intent intent = r.intent;
258         for (int i = queue.size() - 1; i > 0; i--) {
259             final BroadcastRecord old = queue.get(i);
260             if (old.userId == r.userId && intent.filterEquals(old.intent)) {
261                 if (DEBUG_BROADCAST) {
262                     Slog.v(TAG_BROADCAST, "***** DROPPING "
263                             + typeForLogging + " [" + mQueueName + "]: " + intent);
264                 }
265                 queue.set(i, r);
266                 return old;
267             }
268         }
269         return null;
270     }
271 
processCurBroadcastLocked(BroadcastRecord r, ProcessRecord app)272     private final void processCurBroadcastLocked(BroadcastRecord r,
273             ProcessRecord app) throws RemoteException {
274         if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
275                 "Process cur broadcast " + r + " for app " + app);
276         if (app.thread == null) {
277             throw new RemoteException();
278         }
279         if (app.inFullBackup) {
280             skipReceiverLocked(r);
281             return;
282         }
283 
284         r.receiver = app.thread.asBinder();
285         r.curApp = app;
286         app.curReceivers.add(r);
287         app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_RECEIVER);
288         mService.updateLruProcessLocked(app, false, null);
289         mService.updateOomAdjLocked();
290 
291         // Tell the application to launch this receiver.
292         r.intent.setComponent(r.curComponent);
293 
294         boolean started = false;
295         try {
296             if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
297                     "Delivering to component " + r.curComponent
298                     + ": " + r);
299             mService.notifyPackageUse(r.intent.getComponent().getPackageName(),
300                                       PackageManager.NOTIFY_PACKAGE_USE_BROADCAST_RECEIVER);
301             app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver,
302                     mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo),
303                     r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId,
304                     app.repProcState);
305             if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
306                     "Process cur broadcast " + r + " DELIVERED for app " + app);
307             started = true;
308         } finally {
309             if (!started) {
310                 if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
311                         "Process cur broadcast " + r + ": NOT STARTED!");
312                 r.receiver = null;
313                 r.curApp = null;
314                 app.curReceivers.remove(r);
315             }
316         }
317     }
318 
sendPendingBroadcastsLocked(ProcessRecord app)319     public boolean sendPendingBroadcastsLocked(ProcessRecord app) {
320         boolean didSomething = false;
321         final BroadcastRecord br = mPendingBroadcast;
322         if (br != null && br.curApp.pid == app.pid) {
323             if (br.curApp != app) {
324                 Slog.e(TAG, "App mismatch when sending pending broadcast to "
325                         + app.processName + ", intended target is " + br.curApp.processName);
326                 return false;
327             }
328             try {
329                 mPendingBroadcast = null;
330                 processCurBroadcastLocked(br, app);
331                 didSomething = true;
332             } catch (Exception e) {
333                 Slog.w(TAG, "Exception in new application when starting receiver "
334                         + br.curComponent.flattenToShortString(), e);
335                 logBroadcastReceiverDiscardLocked(br);
336                 finishReceiverLocked(br, br.resultCode, br.resultData,
337                         br.resultExtras, br.resultAbort, false);
338                 scheduleBroadcastsLocked();
339                 // We need to reset the state if we failed to start the receiver.
340                 br.state = BroadcastRecord.IDLE;
341                 throw new RuntimeException(e.getMessage());
342             }
343         }
344         return didSomething;
345     }
346 
skipPendingBroadcastLocked(int pid)347     public void skipPendingBroadcastLocked(int pid) {
348         final BroadcastRecord br = mPendingBroadcast;
349         if (br != null && br.curApp.pid == pid) {
350             br.state = BroadcastRecord.IDLE;
351             br.nextReceiver = mPendingBroadcastRecvIndex;
352             mPendingBroadcast = null;
353             scheduleBroadcastsLocked();
354         }
355     }
356 
skipCurrentReceiverLocked(ProcessRecord app)357     public void skipCurrentReceiverLocked(ProcessRecord app) {
358         BroadcastRecord r = null;
359         if (mOrderedBroadcasts.size() > 0) {
360             BroadcastRecord br = mOrderedBroadcasts.get(0);
361             if (br.curApp == app) {
362                 r = br;
363             }
364         }
365         if (r == null && mPendingBroadcast != null && mPendingBroadcast.curApp == app) {
366             if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
367                     "[" + mQueueName + "] skip & discard pending app " + r);
368             r = mPendingBroadcast;
369         }
370 
371         if (r != null) {
372             skipReceiverLocked(r);
373         }
374     }
375 
skipReceiverLocked(BroadcastRecord r)376     private void skipReceiverLocked(BroadcastRecord r) {
377         logBroadcastReceiverDiscardLocked(r);
378         finishReceiverLocked(r, r.resultCode, r.resultData,
379                 r.resultExtras, r.resultAbort, false);
380         scheduleBroadcastsLocked();
381     }
382 
scheduleBroadcastsLocked()383     public void scheduleBroadcastsLocked() {
384         if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Schedule broadcasts ["
385                 + mQueueName + "]: current="
386                 + mBroadcastsScheduled);
387 
388         if (mBroadcastsScheduled) {
389             return;
390         }
391         mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
392         mBroadcastsScheduled = true;
393     }
394 
getMatchingOrderedReceiver(IBinder receiver)395     public BroadcastRecord getMatchingOrderedReceiver(IBinder receiver) {
396         if (mOrderedBroadcasts.size() > 0) {
397             final BroadcastRecord r = mOrderedBroadcasts.get(0);
398             if (r != null && r.receiver == receiver) {
399                 return r;
400             }
401         }
402         return null;
403     }
404 
finishReceiverLocked(BroadcastRecord r, int resultCode, String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices)405     public boolean finishReceiverLocked(BroadcastRecord r, int resultCode,
406             String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices) {
407         final int state = r.state;
408         final ActivityInfo receiver = r.curReceiver;
409         r.state = BroadcastRecord.IDLE;
410         if (state == BroadcastRecord.IDLE) {
411             Slog.w(TAG, "finishReceiver [" + mQueueName + "] called but state is IDLE");
412         }
413         r.receiver = null;
414         r.intent.setComponent(null);
415         if (r.curApp != null && r.curApp.curReceivers.contains(r)) {
416             r.curApp.curReceivers.remove(r);
417         }
418         if (r.curFilter != null) {
419             r.curFilter.receiverList.curBroadcast = null;
420         }
421         r.curFilter = null;
422         r.curReceiver = null;
423         r.curApp = null;
424         mPendingBroadcast = null;
425 
426         r.resultCode = resultCode;
427         r.resultData = resultData;
428         r.resultExtras = resultExtras;
429         if (resultAbort && (r.intent.getFlags()&Intent.FLAG_RECEIVER_NO_ABORT) == 0) {
430             r.resultAbort = resultAbort;
431         } else {
432             r.resultAbort = false;
433         }
434 
435         if (waitForServices && r.curComponent != null && r.queue.mDelayBehindServices
436                 && r.queue.mOrderedBroadcasts.size() > 0
437                 && r.queue.mOrderedBroadcasts.get(0) == r) {
438             ActivityInfo nextReceiver;
439             if (r.nextReceiver < r.receivers.size()) {
440                 Object obj = r.receivers.get(r.nextReceiver);
441                 nextReceiver = (obj instanceof ActivityInfo) ? (ActivityInfo)obj : null;
442             } else {
443                 nextReceiver = null;
444             }
445             // Don't do this if the next receive is in the same process as the current one.
446             if (receiver == null || nextReceiver == null
447                     || receiver.applicationInfo.uid != nextReceiver.applicationInfo.uid
448                     || !receiver.processName.equals(nextReceiver.processName)) {
449                 // In this case, we are ready to process the next receiver for the current broadcast,
450                 // but are on a queue that would like to wait for services to finish before moving
451                 // on.  If there are background services currently starting, then we will go into a
452                 // special state where we hold off on continuing this broadcast until they are done.
453                 if (mService.mServices.hasBackgroundServicesLocked(r.userId)) {
454                     Slog.i(TAG, "Delay finish: " + r.curComponent.flattenToShortString());
455                     r.state = BroadcastRecord.WAITING_SERVICES;
456                     return false;
457                 }
458             }
459         }
460 
461         r.curComponent = null;
462 
463         // We will process the next receiver right now if this is finishing
464         // an app receiver (which is always asynchronous) or after we have
465         // come back from calling a receiver.
466         return state == BroadcastRecord.APP_RECEIVE
467                 || state == BroadcastRecord.CALL_DONE_RECEIVE;
468     }
469 
backgroundServicesFinishedLocked(int userId)470     public void backgroundServicesFinishedLocked(int userId) {
471         if (mOrderedBroadcasts.size() > 0) {
472             BroadcastRecord br = mOrderedBroadcasts.get(0);
473             if (br.userId == userId && br.state == BroadcastRecord.WAITING_SERVICES) {
474                 Slog.i(TAG, "Resuming delayed broadcast");
475                 br.curComponent = null;
476                 br.state = BroadcastRecord.IDLE;
477                 processNextBroadcast(false);
478             }
479         }
480     }
481 
performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser)482     void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
483             Intent intent, int resultCode, String data, Bundle extras,
484             boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
485         // Send the intent to the receiver asynchronously using one-way binder calls.
486         if (app != null) {
487             if (app.thread != null) {
488                 // If we have an app thread, do the call through that so it is
489                 // correctly ordered with other one-way calls.
490                 try {
491                     app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
492                             data, extras, ordered, sticky, sendingUser, app.repProcState);
493                 // TODO: Uncomment this when (b/28322359) is fixed and we aren't getting
494                 // DeadObjectException when the process isn't actually dead.
495                 //} catch (DeadObjectException ex) {
496                 // Failed to call into the process.  It's dying so just let it die and move on.
497                 //    throw ex;
498                 } catch (RemoteException ex) {
499                     // Failed to call into the process. It's either dying or wedged. Kill it gently.
500                     synchronized (mService) {
501                         Slog.w(TAG, "Can't deliver broadcast to " + app.processName
502                                 + " (pid " + app.pid + "). Crashing it.");
503                         app.scheduleCrash("can't deliver broadcast");
504                     }
505                     throw ex;
506                 }
507             } else {
508                 // Application has died. Receiver doesn't exist.
509                 throw new RemoteException("app.thread must not be null");
510             }
511         } else {
512             receiver.performReceive(intent, resultCode, data, extras, ordered,
513                     sticky, sendingUser);
514         }
515     }
516 
deliverToRegisteredReceiverLocked(BroadcastRecord r, BroadcastFilter filter, boolean ordered, int index)517     private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
518             BroadcastFilter filter, boolean ordered, int index) {
519         boolean skip = false;
520         if (filter.requiredPermission != null) {
521             int perm = mService.checkComponentPermission(filter.requiredPermission,
522                     r.callingPid, r.callingUid, -1, true);
523             if (perm != PackageManager.PERMISSION_GRANTED) {
524                 Slog.w(TAG, "Permission Denial: broadcasting "
525                         + r.intent.toString()
526                         + " from " + r.callerPackage + " (pid="
527                         + r.callingPid + ", uid=" + r.callingUid + ")"
528                         + " requires " + filter.requiredPermission
529                         + " due to registered receiver " + filter);
530                 skip = true;
531             } else {
532                 final int opCode = AppOpsManager.permissionToOpCode(filter.requiredPermission);
533                 if (opCode != AppOpsManager.OP_NONE
534                         && mService.mAppOpsService.noteOperation(opCode, r.callingUid,
535                                 r.callerPackage) != AppOpsManager.MODE_ALLOWED) {
536                     Slog.w(TAG, "Appop Denial: broadcasting "
537                             + r.intent.toString()
538                             + " from " + r.callerPackage + " (pid="
539                             + r.callingPid + ", uid=" + r.callingUid + ")"
540                             + " requires appop " + AppOpsManager.permissionToOp(
541                                     filter.requiredPermission)
542                             + " due to registered receiver " + filter);
543                     skip = true;
544                 }
545             }
546         }
547         if (!skip && r.requiredPermissions != null && r.requiredPermissions.length > 0) {
548             for (int i = 0; i < r.requiredPermissions.length; i++) {
549                 String requiredPermission = r.requiredPermissions[i];
550                 int perm = mService.checkComponentPermission(requiredPermission,
551                         filter.receiverList.pid, filter.receiverList.uid, -1, true);
552                 if (perm != PackageManager.PERMISSION_GRANTED) {
553                     Slog.w(TAG, "Permission Denial: receiving "
554                             + r.intent.toString()
555                             + " to " + filter.receiverList.app
556                             + " (pid=" + filter.receiverList.pid
557                             + ", uid=" + filter.receiverList.uid + ")"
558                             + " requires " + requiredPermission
559                             + " due to sender " + r.callerPackage
560                             + " (uid " + r.callingUid + ")");
561                     skip = true;
562                     break;
563                 }
564                 int appOp = AppOpsManager.permissionToOpCode(requiredPermission);
565                 if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp
566                         && mService.mAppOpsService.noteOperation(appOp,
567                         filter.receiverList.uid, filter.packageName)
568                         != AppOpsManager.MODE_ALLOWED) {
569                     Slog.w(TAG, "Appop Denial: receiving "
570                             + r.intent.toString()
571                             + " to " + filter.receiverList.app
572                             + " (pid=" + filter.receiverList.pid
573                             + ", uid=" + filter.receiverList.uid + ")"
574                             + " requires appop " + AppOpsManager.permissionToOp(
575                             requiredPermission)
576                             + " due to sender " + r.callerPackage
577                             + " (uid " + r.callingUid + ")");
578                     skip = true;
579                     break;
580                 }
581             }
582         }
583         if (!skip && (r.requiredPermissions == null || r.requiredPermissions.length == 0)) {
584             int perm = mService.checkComponentPermission(null,
585                     filter.receiverList.pid, filter.receiverList.uid, -1, true);
586             if (perm != PackageManager.PERMISSION_GRANTED) {
587                 Slog.w(TAG, "Permission Denial: security check failed when receiving "
588                         + r.intent.toString()
589                         + " to " + filter.receiverList.app
590                         + " (pid=" + filter.receiverList.pid
591                         + ", uid=" + filter.receiverList.uid + ")"
592                         + " due to sender " + r.callerPackage
593                         + " (uid " + r.callingUid + ")");
594                 skip = true;
595             }
596         }
597         if (!skip && r.appOp != AppOpsManager.OP_NONE
598                 && mService.mAppOpsService.noteOperation(r.appOp,
599                 filter.receiverList.uid, filter.packageName)
600                 != AppOpsManager.MODE_ALLOWED) {
601             Slog.w(TAG, "Appop Denial: receiving "
602                     + r.intent.toString()
603                     + " to " + filter.receiverList.app
604                     + " (pid=" + filter.receiverList.pid
605                     + ", uid=" + filter.receiverList.uid + ")"
606                     + " requires appop " + AppOpsManager.opToName(r.appOp)
607                     + " due to sender " + r.callerPackage
608                     + " (uid " + r.callingUid + ")");
609             skip = true;
610         }
611 
612         if (!mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
613                 r.callingPid, r.resolvedType, filter.receiverList.uid)) {
614             skip = true;
615         }
616 
617         if (!skip && (filter.receiverList.app == null || filter.receiverList.app.killed
618                 || filter.receiverList.app.crashing)) {
619             Slog.w(TAG, "Skipping deliver [" + mQueueName + "] " + r
620                     + " to " + filter.receiverList + ": process gone or crashing");
621             skip = true;
622         }
623 
624         // Ensure that broadcasts are only sent to other Instant Apps if they are marked as
625         // visible to Instant Apps.
626         final boolean visibleToInstantApps =
627                 (r.intent.getFlags() & Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS) != 0;
628 
629         if (!skip && !visibleToInstantApps && filter.instantApp
630                 && filter.receiverList.uid != r.callingUid) {
631             Slog.w(TAG, "Instant App Denial: receiving "
632                     + r.intent.toString()
633                     + " to " + filter.receiverList.app
634                     + " (pid=" + filter.receiverList.pid
635                     + ", uid=" + filter.receiverList.uid + ")"
636                     + " due to sender " + r.callerPackage
637                     + " (uid " + r.callingUid + ")"
638                     + " not specifying FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS");
639             skip = true;
640         }
641 
642         if (!skip && !filter.visibleToInstantApp && r.callerInstantApp
643                 && filter.receiverList.uid != r.callingUid) {
644             Slog.w(TAG, "Instant App Denial: receiving "
645                     + r.intent.toString()
646                     + " to " + filter.receiverList.app
647                     + " (pid=" + filter.receiverList.pid
648                     + ", uid=" + filter.receiverList.uid + ")"
649                     + " requires receiver be visible to instant apps"
650                     + " due to sender " + r.callerPackage
651                     + " (uid " + r.callingUid + ")");
652             skip = true;
653         }
654 
655         if (skip) {
656             r.delivery[index] = BroadcastRecord.DELIVERY_SKIPPED;
657             return;
658         }
659 
660         // If permissions need a review before any of the app components can run, we drop
661         // the broadcast and if the calling app is in the foreground and the broadcast is
662         // explicit we launch the review UI passing it a pending intent to send the skipped
663         // broadcast.
664         if (mService.mPermissionReviewRequired) {
665             if (!requestStartTargetPermissionsReviewIfNeededLocked(r, filter.packageName,
666                     filter.owningUserId)) {
667                 r.delivery[index] = BroadcastRecord.DELIVERY_SKIPPED;
668                 return;
669             }
670         }
671 
672         r.delivery[index] = BroadcastRecord.DELIVERY_DELIVERED;
673 
674         // If this is not being sent as an ordered broadcast, then we
675         // don't want to touch the fields that keep track of the current
676         // state of ordered broadcasts.
677         if (ordered) {
678             r.receiver = filter.receiverList.receiver.asBinder();
679             r.curFilter = filter;
680             filter.receiverList.curBroadcast = r;
681             r.state = BroadcastRecord.CALL_IN_RECEIVE;
682             if (filter.receiverList.app != null) {
683                 // Bump hosting application to no longer be in background
684                 // scheduling class.  Note that we can't do that if there
685                 // isn't an app...  but we can only be in that case for
686                 // things that directly call the IActivityManager API, which
687                 // are already core system stuff so don't matter for this.
688                 r.curApp = filter.receiverList.app;
689                 filter.receiverList.app.curReceivers.add(r);
690                 mService.updateOomAdjLocked(r.curApp, true);
691             }
692         }
693         try {
694             if (DEBUG_BROADCAST_LIGHT) Slog.i(TAG_BROADCAST,
695                     "Delivering to " + filter + " : " + r);
696             if (filter.receiverList.app != null && filter.receiverList.app.inFullBackup) {
697                 // Skip delivery if full backup in progress
698                 // If it's an ordered broadcast, we need to continue to the next receiver.
699                 if (ordered) {
700                     skipReceiverLocked(r);
701                 }
702             } else {
703                 performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
704                         new Intent(r.intent), r.resultCode, r.resultData,
705                         r.resultExtras, r.ordered, r.initialSticky, r.userId);
706             }
707             if (ordered) {
708                 r.state = BroadcastRecord.CALL_DONE_RECEIVE;
709             }
710         } catch (RemoteException e) {
711             Slog.w(TAG, "Failure sending broadcast " + r.intent, e);
712             if (ordered) {
713                 r.receiver = null;
714                 r.curFilter = null;
715                 filter.receiverList.curBroadcast = null;
716                 if (filter.receiverList.app != null) {
717                     filter.receiverList.app.curReceivers.remove(r);
718                 }
719             }
720         }
721     }
722 
requestStartTargetPermissionsReviewIfNeededLocked( BroadcastRecord receiverRecord, String receivingPackageName, final int receivingUserId)723     private boolean requestStartTargetPermissionsReviewIfNeededLocked(
724             BroadcastRecord receiverRecord, String receivingPackageName,
725             final int receivingUserId) {
726         if (!mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
727                 receivingPackageName, receivingUserId)) {
728             return true;
729         }
730 
731         final boolean callerForeground = receiverRecord.callerApp != null
732                 ? receiverRecord.callerApp.setSchedGroup != ProcessList.SCHED_GROUP_BACKGROUND
733                 : true;
734 
735         // Show a permission review UI only for explicit broadcast from a foreground app
736         if (callerForeground && receiverRecord.intent.getComponent() != null) {
737             IIntentSender target = mService.getIntentSenderLocked(
738                     ActivityManager.INTENT_SENDER_BROADCAST, receiverRecord.callerPackage,
739                     receiverRecord.callingUid, receiverRecord.userId, null, null, 0,
740                     new Intent[]{receiverRecord.intent},
741                     new String[]{receiverRecord.intent.resolveType(mService.mContext
742                             .getContentResolver())},
743                     PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT
744                             | PendingIntent.FLAG_IMMUTABLE, null);
745 
746             final Intent intent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
747             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
748                     | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
749             intent.putExtra(Intent.EXTRA_PACKAGE_NAME, receivingPackageName);
750             intent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target));
751 
752             if (DEBUG_PERMISSIONS_REVIEW) {
753                 Slog.i(TAG, "u" + receivingUserId + " Launching permission review for package "
754                         + receivingPackageName);
755             }
756 
757             mHandler.post(new Runnable() {
758                 @Override
759                 public void run() {
760                     mService.mContext.startActivityAsUser(intent, new UserHandle(receivingUserId));
761                 }
762             });
763         } else {
764             Slog.w(TAG, "u" + receivingUserId + " Receiving a broadcast in package"
765                     + receivingPackageName + " requires a permissions review");
766         }
767 
768         return false;
769     }
770 
scheduleTempWhitelistLocked(int uid, long duration, BroadcastRecord r)771     final void scheduleTempWhitelistLocked(int uid, long duration, BroadcastRecord r) {
772         if (duration > Integer.MAX_VALUE) {
773             duration = Integer.MAX_VALUE;
774         }
775         // XXX ideally we should pause the broadcast until everything behind this is done,
776         // or else we will likely start dispatching the broadcast before we have opened
777         // access to the app (there is a lot of asynchronicity behind this).  It is probably
778         // not that big a deal, however, because the main purpose here is to allow apps
779         // to hold wake locks, and they will be able to acquire their wake lock immediately
780         // it just won't be enabled until we get through this work.
781         StringBuilder b = new StringBuilder();
782         b.append("broadcast:");
783         UserHandle.formatUid(b, r.callingUid);
784         b.append(":");
785         if (r.intent.getAction() != null) {
786             b.append(r.intent.getAction());
787         } else if (r.intent.getComponent() != null) {
788             r.intent.getComponent().appendShortString(b);
789         } else if (r.intent.getData() != null) {
790             b.append(r.intent.getData());
791         }
792         mService.tempWhitelistUidLocked(uid, duration, b.toString());
793     }
794 
795     /**
796      * Return true if all given permissions are signature-only perms.
797      */
isSignaturePerm(String[] perms)798     final boolean isSignaturePerm(String[] perms) {
799         if (perms == null) {
800             return false;
801         }
802         IPackageManager pm = AppGlobals.getPackageManager();
803         for (int i = perms.length-1; i >= 0; i--) {
804             try {
805                 PermissionInfo pi = pm.getPermissionInfo(perms[i], "android", 0);
806                 if ((pi.protectionLevel & (PermissionInfo.PROTECTION_MASK_BASE
807                         | PermissionInfo.PROTECTION_FLAG_PRIVILEGED))
808                         != PermissionInfo.PROTECTION_SIGNATURE) {
809                     // If this a signature permission and NOT allowed for privileged apps, it
810                     // is okay...  otherwise, nope!
811                     return false;
812                 }
813             } catch (RemoteException e) {
814                 return false;
815             }
816         }
817         return true;
818     }
819 
processNextBroadcast(boolean fromMsg)820     final void processNextBroadcast(boolean fromMsg) {
821         synchronized(mService) {
822             BroadcastRecord r;
823 
824             if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "processNextBroadcast ["
825                     + mQueueName + "]: "
826                     + mParallelBroadcasts.size() + " parallel broadcasts, "
827                     + mOrderedBroadcasts.size() + " ordered broadcasts");
828 
829             mService.updateCpuStats();
830 
831             if (fromMsg) {
832                 mBroadcastsScheduled = false;
833             }
834 
835             // First, deliver any non-serialized broadcasts right away.
836             while (mParallelBroadcasts.size() > 0) {
837                 r = mParallelBroadcasts.remove(0);
838                 r.dispatchTime = SystemClock.uptimeMillis();
839                 r.dispatchClockTime = System.currentTimeMillis();
840 
841                 if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
842                     Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
843                         createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
844                         System.identityHashCode(r));
845                     Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
846                         createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
847                         System.identityHashCode(r));
848                 }
849 
850                 final int N = r.receivers.size();
851                 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing parallel broadcast ["
852                         + mQueueName + "] " + r);
853                 for (int i=0; i<N; i++) {
854                     Object target = r.receivers.get(i);
855                     if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
856                             "Delivering non-ordered on [" + mQueueName + "] to registered "
857                             + target + ": " + r);
858                     deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
859                 }
860                 addBroadcastToHistoryLocked(r);
861                 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Done with parallel broadcast ["
862                         + mQueueName + "] " + r);
863             }
864 
865             // Now take care of the next serialized one...
866 
867             // If we are waiting for a process to come up to handle the next
868             // broadcast, then do nothing at this point.  Just in case, we
869             // check that the process we're waiting for still exists.
870             if (mPendingBroadcast != null) {
871                 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
872                         "processNextBroadcast [" + mQueueName + "]: waiting for "
873                         + mPendingBroadcast.curApp);
874 
875                 boolean isDead;
876                 synchronized (mService.mPidsSelfLocked) {
877                     ProcessRecord proc = mService.mPidsSelfLocked.get(mPendingBroadcast.curApp.pid);
878                     isDead = proc == null || proc.crashing;
879                 }
880                 if (!isDead) {
881                     // It's still alive, so keep waiting
882                     return;
883                 } else {
884                     Slog.w(TAG, "pending app  ["
885                             + mQueueName + "]" + mPendingBroadcast.curApp
886                             + " died before responding to broadcast");
887                     mPendingBroadcast.state = BroadcastRecord.IDLE;
888                     mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;
889                     mPendingBroadcast = null;
890                 }
891             }
892 
893             boolean looped = false;
894 
895             do {
896                 if (mOrderedBroadcasts.size() == 0) {
897                     // No more broadcasts pending, so all done!
898                     mService.scheduleAppGcsLocked();
899                     if (looped) {
900                         // If we had finished the last ordered broadcast, then
901                         // make sure all processes have correct oom and sched
902                         // adjustments.
903                         mService.updateOomAdjLocked();
904                     }
905                     return;
906                 }
907                 r = mOrderedBroadcasts.get(0);
908                 boolean forceReceive = false;
909 
910                 // Ensure that even if something goes awry with the timeout
911                 // detection, we catch "hung" broadcasts here, discard them,
912                 // and continue to make progress.
913                 //
914                 // This is only done if the system is ready so that PRE_BOOT_COMPLETED
915                 // receivers don't get executed with timeouts. They're intended for
916                 // one time heavy lifting after system upgrades and can take
917                 // significant amounts of time.
918                 int numReceivers = (r.receivers != null) ? r.receivers.size() : 0;
919                 if (mService.mProcessesReady && r.dispatchTime > 0) {
920                     long now = SystemClock.uptimeMillis();
921                     if ((numReceivers > 0) &&
922                             (now > r.dispatchTime + (2*mTimeoutPeriod*numReceivers))) {
923                         Slog.w(TAG, "Hung broadcast ["
924                                 + mQueueName + "] discarded after timeout failure:"
925                                 + " now=" + now
926                                 + " dispatchTime=" + r.dispatchTime
927                                 + " startTime=" + r.receiverTime
928                                 + " intent=" + r.intent
929                                 + " numReceivers=" + numReceivers
930                                 + " nextReceiver=" + r.nextReceiver
931                                 + " state=" + r.state);
932                         broadcastTimeoutLocked(false); // forcibly finish this broadcast
933                         forceReceive = true;
934                         r.state = BroadcastRecord.IDLE;
935                     }
936                 }
937 
938                 if (r.state != BroadcastRecord.IDLE) {
939                     if (DEBUG_BROADCAST) Slog.d(TAG_BROADCAST,
940                             "processNextBroadcast("
941                             + mQueueName + ") called when not idle (state="
942                             + r.state + ")");
943                     return;
944                 }
945 
946                 if (r.receivers == null || r.nextReceiver >= numReceivers
947                         || r.resultAbort || forceReceive) {
948                     // No more receivers for this broadcast!  Send the final
949                     // result if requested...
950                     if (r.resultTo != null) {
951                         try {
952                             if (DEBUG_BROADCAST) Slog.i(TAG_BROADCAST,
953                                     "Finishing broadcast [" + mQueueName + "] "
954                                     + r.intent.getAction() + " app=" + r.callerApp);
955                             performReceiveLocked(r.callerApp, r.resultTo,
956                                 new Intent(r.intent), r.resultCode,
957                                 r.resultData, r.resultExtras, false, false, r.userId);
958                             // Set this to null so that the reference
959                             // (local and remote) isn't kept in the mBroadcastHistory.
960                             r.resultTo = null;
961                         } catch (RemoteException e) {
962                             r.resultTo = null;
963                             Slog.w(TAG, "Failure ["
964                                     + mQueueName + "] sending broadcast result of "
965                                     + r.intent, e);
966 
967                         }
968                     }
969 
970                     if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Cancelling BROADCAST_TIMEOUT_MSG");
971                     cancelBroadcastTimeoutLocked();
972 
973                     if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
974                             "Finished with ordered broadcast " + r);
975 
976                     // ... and on to the next...
977                     addBroadcastToHistoryLocked(r);
978                     if (r.intent.getComponent() == null && r.intent.getPackage() == null
979                             && (r.intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
980                         // This was an implicit broadcast... let's record it for posterity.
981                         mService.addBroadcastStatLocked(r.intent.getAction(), r.callerPackage,
982                                 r.manifestCount, r.manifestSkipCount, r.finishTime-r.dispatchTime);
983                     }
984                     mOrderedBroadcasts.remove(0);
985                     r = null;
986                     looped = true;
987                     continue;
988                 }
989             } while (r == null);
990 
991             // Get the next receiver...
992             int recIdx = r.nextReceiver++;
993 
994             // Keep track of when this receiver started, and make sure there
995             // is a timeout message pending to kill it if need be.
996             r.receiverTime = SystemClock.uptimeMillis();
997             if (recIdx == 0) {
998                 r.dispatchTime = r.receiverTime;
999                 r.dispatchClockTime = System.currentTimeMillis();
1000                 if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
1001                     Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
1002                         createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
1003                         System.identityHashCode(r));
1004                     Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
1005                         createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
1006                         System.identityHashCode(r));
1007                 }
1008                 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing ordered broadcast ["
1009                         + mQueueName + "] " + r);
1010             }
1011             if (! mPendingBroadcastTimeoutMessage) {
1012                 long timeoutTime = r.receiverTime + mTimeoutPeriod;
1013                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
1014                         "Submitting BROADCAST_TIMEOUT_MSG ["
1015                         + mQueueName + "] for " + r + " at " + timeoutTime);
1016                 setBroadcastTimeoutLocked(timeoutTime);
1017             }
1018 
1019             final BroadcastOptions brOptions = r.options;
1020             final Object nextReceiver = r.receivers.get(recIdx);
1021 
1022             if (nextReceiver instanceof BroadcastFilter) {
1023                 // Simple case: this is a registered receiver who gets
1024                 // a direct call.
1025                 BroadcastFilter filter = (BroadcastFilter)nextReceiver;
1026                 if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
1027                         "Delivering ordered ["
1028                         + mQueueName + "] to registered "
1029                         + filter + ": " + r);
1030                 deliverToRegisteredReceiverLocked(r, filter, r.ordered, recIdx);
1031                 if (r.receiver == null || !r.ordered) {
1032                     // The receiver has already finished, so schedule to
1033                     // process the next one.
1034                     if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Quick finishing ["
1035                             + mQueueName + "]: ordered="
1036                             + r.ordered + " receiver=" + r.receiver);
1037                     r.state = BroadcastRecord.IDLE;
1038                     scheduleBroadcastsLocked();
1039                 } else {
1040                     if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
1041                         scheduleTempWhitelistLocked(filter.owningUid,
1042                                 brOptions.getTemporaryAppWhitelistDuration(), r);
1043                     }
1044                 }
1045                 return;
1046             }
1047 
1048             // Hard case: need to instantiate the receiver, possibly
1049             // starting its application process to host it.
1050 
1051             ResolveInfo info =
1052                 (ResolveInfo)nextReceiver;
1053             ComponentName component = new ComponentName(
1054                     info.activityInfo.applicationInfo.packageName,
1055                     info.activityInfo.name);
1056 
1057             boolean skip = false;
1058             if (brOptions != null &&
1059                     (info.activityInfo.applicationInfo.targetSdkVersion
1060                             < brOptions.getMinManifestReceiverApiLevel() ||
1061                     info.activityInfo.applicationInfo.targetSdkVersion
1062                             > brOptions.getMaxManifestReceiverApiLevel())) {
1063                 skip = true;
1064             }
1065             int perm = mService.checkComponentPermission(info.activityInfo.permission,
1066                     r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid,
1067                     info.activityInfo.exported);
1068             if (!skip && perm != PackageManager.PERMISSION_GRANTED) {
1069                 if (!info.activityInfo.exported) {
1070                     Slog.w(TAG, "Permission Denial: broadcasting "
1071                             + r.intent.toString()
1072                             + " from " + r.callerPackage + " (pid=" + r.callingPid
1073                             + ", uid=" + r.callingUid + ")"
1074                             + " is not exported from uid " + info.activityInfo.applicationInfo.uid
1075                             + " due to receiver " + component.flattenToShortString());
1076                 } else {
1077                     Slog.w(TAG, "Permission Denial: broadcasting "
1078                             + r.intent.toString()
1079                             + " from " + r.callerPackage + " (pid=" + r.callingPid
1080                             + ", uid=" + r.callingUid + ")"
1081                             + " requires " + info.activityInfo.permission
1082                             + " due to receiver " + component.flattenToShortString());
1083                 }
1084                 skip = true;
1085             } else if (!skip && info.activityInfo.permission != null) {
1086                 final int opCode = AppOpsManager.permissionToOpCode(info.activityInfo.permission);
1087                 if (opCode != AppOpsManager.OP_NONE
1088                         && mService.mAppOpsService.noteOperation(opCode, r.callingUid,
1089                                 r.callerPackage) != AppOpsManager.MODE_ALLOWED) {
1090                     Slog.w(TAG, "Appop Denial: broadcasting "
1091                             + r.intent.toString()
1092                             + " from " + r.callerPackage + " (pid="
1093                             + r.callingPid + ", uid=" + r.callingUid + ")"
1094                             + " requires appop " + AppOpsManager.permissionToOp(
1095                                     info.activityInfo.permission)
1096                             + " due to registered receiver "
1097                             + component.flattenToShortString());
1098                     skip = true;
1099                 }
1100             }
1101             if (!skip && info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID &&
1102                 r.requiredPermissions != null && r.requiredPermissions.length > 0) {
1103                 for (int i = 0; i < r.requiredPermissions.length; i++) {
1104                     String requiredPermission = r.requiredPermissions[i];
1105                     try {
1106                         perm = AppGlobals.getPackageManager().
1107                                 checkPermission(requiredPermission,
1108                                         info.activityInfo.applicationInfo.packageName,
1109                                         UserHandle
1110                                                 .getUserId(info.activityInfo.applicationInfo.uid));
1111                     } catch (RemoteException e) {
1112                         perm = PackageManager.PERMISSION_DENIED;
1113                     }
1114                     if (perm != PackageManager.PERMISSION_GRANTED) {
1115                         Slog.w(TAG, "Permission Denial: receiving "
1116                                 + r.intent + " to "
1117                                 + component.flattenToShortString()
1118                                 + " requires " + requiredPermission
1119                                 + " due to sender " + r.callerPackage
1120                                 + " (uid " + r.callingUid + ")");
1121                         skip = true;
1122                         break;
1123                     }
1124                     int appOp = AppOpsManager.permissionToOpCode(requiredPermission);
1125                     if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp
1126                             && mService.mAppOpsService.noteOperation(appOp,
1127                             info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
1128                             != AppOpsManager.MODE_ALLOWED) {
1129                         Slog.w(TAG, "Appop Denial: receiving "
1130                                 + r.intent + " to "
1131                                 + component.flattenToShortString()
1132                                 + " requires appop " + AppOpsManager.permissionToOp(
1133                                 requiredPermission)
1134                                 + " due to sender " + r.callerPackage
1135                                 + " (uid " + r.callingUid + ")");
1136                         skip = true;
1137                         break;
1138                     }
1139                 }
1140             }
1141             if (!skip && r.appOp != AppOpsManager.OP_NONE
1142                     && mService.mAppOpsService.noteOperation(r.appOp,
1143                     info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
1144                     != AppOpsManager.MODE_ALLOWED) {
1145                 Slog.w(TAG, "Appop Denial: receiving "
1146                         + r.intent + " to "
1147                         + component.flattenToShortString()
1148                         + " requires appop " + AppOpsManager.opToName(r.appOp)
1149                         + " due to sender " + r.callerPackage
1150                         + " (uid " + r.callingUid + ")");
1151                 skip = true;
1152             }
1153             if (!skip) {
1154                 skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
1155                         r.callingPid, r.resolvedType, info.activityInfo.applicationInfo.uid);
1156             }
1157             boolean isSingleton = false;
1158             try {
1159                 isSingleton = mService.isSingleton(info.activityInfo.processName,
1160                         info.activityInfo.applicationInfo,
1161                         info.activityInfo.name, info.activityInfo.flags);
1162             } catch (SecurityException e) {
1163                 Slog.w(TAG, e.getMessage());
1164                 skip = true;
1165             }
1166             if ((info.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {
1167                 if (ActivityManager.checkUidPermission(
1168                         android.Manifest.permission.INTERACT_ACROSS_USERS,
1169                         info.activityInfo.applicationInfo.uid)
1170                                 != PackageManager.PERMISSION_GRANTED) {
1171                     Slog.w(TAG, "Permission Denial: Receiver " + component.flattenToShortString()
1172                             + " requests FLAG_SINGLE_USER, but app does not hold "
1173                             + android.Manifest.permission.INTERACT_ACROSS_USERS);
1174                     skip = true;
1175                 }
1176             }
1177             if (!skip && info.activityInfo.applicationInfo.isInstantApp()
1178                     && r.callingUid != info.activityInfo.applicationInfo.uid) {
1179                 Slog.w(TAG, "Instant App Denial: receiving "
1180                         + r.intent
1181                         + " to " + component.flattenToShortString()
1182                         + " due to sender " + r.callerPackage
1183                         + " (uid " + r.callingUid + ")"
1184                         + " Instant Apps do not support manifest receivers");
1185                 skip = true;
1186             }
1187             if (!skip && r.callerInstantApp
1188                     && (info.activityInfo.flags & ActivityInfo.FLAG_VISIBLE_TO_INSTANT_APP) == 0
1189                     && r.callingUid != info.activityInfo.applicationInfo.uid) {
1190                 Slog.w(TAG, "Instant App Denial: receiving "
1191                         + r.intent
1192                         + " to " + component.flattenToShortString()
1193                         + " requires receiver have visibleToInstantApps set"
1194                         + " due to sender " + r.callerPackage
1195                         + " (uid " + r.callingUid + ")");
1196                 skip = true;
1197             }
1198             if (!skip) {
1199                 r.manifestCount++;
1200             } else {
1201                 r.manifestSkipCount++;
1202             }
1203             if (r.curApp != null && r.curApp.crashing) {
1204                 // If the target process is crashing, just skip it.
1205                 Slog.w(TAG, "Skipping deliver ordered [" + mQueueName + "] " + r
1206                         + " to " + r.curApp + ": process crashing");
1207                 skip = true;
1208             }
1209             if (!skip) {
1210                 boolean isAvailable = false;
1211                 try {
1212                     isAvailable = AppGlobals.getPackageManager().isPackageAvailable(
1213                             info.activityInfo.packageName,
1214                             UserHandle.getUserId(info.activityInfo.applicationInfo.uid));
1215                 } catch (Exception e) {
1216                     // all such failures mean we skip this receiver
1217                     Slog.w(TAG, "Exception getting recipient info for "
1218                             + info.activityInfo.packageName, e);
1219                 }
1220                 if (!isAvailable) {
1221                     if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
1222                             "Skipping delivery to " + info.activityInfo.packageName + " / "
1223                             + info.activityInfo.applicationInfo.uid
1224                             + " : package no longer available");
1225                     skip = true;
1226                 }
1227             }
1228 
1229             // If permissions need a review before any of the app components can run, we drop
1230             // the broadcast and if the calling app is in the foreground and the broadcast is
1231             // explicit we launch the review UI passing it a pending intent to send the skipped
1232             // broadcast.
1233             if (mService.mPermissionReviewRequired && !skip) {
1234                 if (!requestStartTargetPermissionsReviewIfNeededLocked(r,
1235                         info.activityInfo.packageName, UserHandle.getUserId(
1236                                 info.activityInfo.applicationInfo.uid))) {
1237                     skip = true;
1238                 }
1239             }
1240 
1241             // This is safe to do even if we are skipping the broadcast, and we need
1242             // this information now to evaluate whether it is going to be allowed to run.
1243             final int receiverUid = info.activityInfo.applicationInfo.uid;
1244             // If it's a singleton, it needs to be the same app or a special app
1245             if (r.callingUid != Process.SYSTEM_UID && isSingleton
1246                     && mService.isValidSingletonCall(r.callingUid, receiverUid)) {
1247                 info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0);
1248             }
1249             String targetProcess = info.activityInfo.processName;
1250             ProcessRecord app = mService.getProcessRecordLocked(targetProcess,
1251                     info.activityInfo.applicationInfo.uid, false);
1252 
1253             if (!skip) {
1254                 final int allowed = mService.getAppStartModeLocked(
1255                         info.activityInfo.applicationInfo.uid, info.activityInfo.packageName,
1256                         info.activityInfo.applicationInfo.targetSdkVersion, -1, true, false);
1257                 if (allowed != ActivityManager.APP_START_MODE_NORMAL) {
1258                     // We won't allow this receiver to be launched if the app has been
1259                     // completely disabled from launches, or it was not explicitly sent
1260                     // to it and the app is in a state that should not receive it
1261                     // (depending on how getAppStartModeLocked has determined that).
1262                     if (allowed == ActivityManager.APP_START_MODE_DISABLED) {
1263                         Slog.w(TAG, "Background execution disabled: receiving "
1264                                 + r.intent + " to "
1265                                 + component.flattenToShortString());
1266                         skip = true;
1267                     } else if (((r.intent.getFlags()&Intent.FLAG_RECEIVER_EXCLUDE_BACKGROUND) != 0)
1268                             || (r.intent.getComponent() == null
1269                                 && r.intent.getPackage() == null
1270                                 && ((r.intent.getFlags()
1271                                         & Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND) == 0)
1272                                 && !isSignaturePerm(r.requiredPermissions))) {
1273                         mService.addBackgroundCheckViolationLocked(r.intent.getAction(),
1274                                 component.getPackageName());
1275                         Slog.w(TAG, "Background execution not allowed: receiving "
1276                                 + r.intent + " to "
1277                                 + component.flattenToShortString());
1278                         skip = true;
1279                     }
1280                 }
1281             }
1282 
1283             if (skip) {
1284                 if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
1285                         "Skipping delivery of ordered [" + mQueueName + "] "
1286                         + r + " for whatever reason");
1287                 r.delivery[recIdx] = BroadcastRecord.DELIVERY_SKIPPED;
1288                 r.receiver = null;
1289                 r.curFilter = null;
1290                 r.state = BroadcastRecord.IDLE;
1291                 scheduleBroadcastsLocked();
1292                 return;
1293             }
1294 
1295             r.delivery[recIdx] = BroadcastRecord.DELIVERY_DELIVERED;
1296             r.state = BroadcastRecord.APP_RECEIVE;
1297             r.curComponent = component;
1298             r.curReceiver = info.activityInfo;
1299             if (DEBUG_MU && r.callingUid > UserHandle.PER_USER_RANGE) {
1300                 Slog.v(TAG_MU, "Updated broadcast record activity info for secondary user, "
1301                         + info.activityInfo + ", callingUid = " + r.callingUid + ", uid = "
1302                         + info.activityInfo.applicationInfo.uid);
1303             }
1304 
1305             if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
1306                 scheduleTempWhitelistLocked(receiverUid,
1307                         brOptions.getTemporaryAppWhitelistDuration(), r);
1308             }
1309 
1310             // Broadcast is being executed, its package can't be stopped.
1311             try {
1312                 AppGlobals.getPackageManager().setPackageStoppedState(
1313                         r.curComponent.getPackageName(), false, UserHandle.getUserId(r.callingUid));
1314             } catch (RemoteException e) {
1315             } catch (IllegalArgumentException e) {
1316                 Slog.w(TAG, "Failed trying to unstop package "
1317                         + r.curComponent.getPackageName() + ": " + e);
1318             }
1319 
1320             // Is this receiver's application already running?
1321             if (app != null && app.thread != null && !app.killed) {
1322                 try {
1323                     app.addPackage(info.activityInfo.packageName,
1324                             info.activityInfo.applicationInfo.versionCode, mService.mProcessStats);
1325                     processCurBroadcastLocked(r, app);
1326                     return;
1327                 } catch (RemoteException e) {
1328                     Slog.w(TAG, "Exception when sending broadcast to "
1329                           + r.curComponent, e);
1330                 } catch (RuntimeException e) {
1331                     Slog.wtf(TAG, "Failed sending broadcast to "
1332                             + r.curComponent + " with " + r.intent, e);
1333                     // If some unexpected exception happened, just skip
1334                     // this broadcast.  At this point we are not in the call
1335                     // from a client, so throwing an exception out from here
1336                     // will crash the entire system instead of just whoever
1337                     // sent the broadcast.
1338                     logBroadcastReceiverDiscardLocked(r);
1339                     finishReceiverLocked(r, r.resultCode, r.resultData,
1340                             r.resultExtras, r.resultAbort, false);
1341                     scheduleBroadcastsLocked();
1342                     // We need to reset the state if we failed to start the receiver.
1343                     r.state = BroadcastRecord.IDLE;
1344                     return;
1345                 }
1346 
1347                 // If a dead object exception was thrown -- fall through to
1348                 // restart the application.
1349             }
1350 
1351             // Not running -- get it started, to be executed when the app comes up.
1352             if (DEBUG_BROADCAST)  Slog.v(TAG_BROADCAST,
1353                     "Need to start app ["
1354                     + mQueueName + "] " + targetProcess + " for broadcast " + r);
1355             if ((r.curApp=mService.startProcessLocked(targetProcess,
1356                     info.activityInfo.applicationInfo, true,
1357                     r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND,
1358                     "broadcast", r.curComponent,
1359                     (r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0, false, false))
1360                             == null) {
1361                 // Ah, this recipient is unavailable.  Finish it if necessary,
1362                 // and mark the broadcast record as ready for the next.
1363                 Slog.w(TAG, "Unable to launch app "
1364                         + info.activityInfo.applicationInfo.packageName + "/"
1365                         + info.activityInfo.applicationInfo.uid + " for broadcast "
1366                         + r.intent + ": process is bad");
1367                 logBroadcastReceiverDiscardLocked(r);
1368                 finishReceiverLocked(r, r.resultCode, r.resultData,
1369                         r.resultExtras, r.resultAbort, false);
1370                 scheduleBroadcastsLocked();
1371                 r.state = BroadcastRecord.IDLE;
1372                 return;
1373             }
1374 
1375             mPendingBroadcast = r;
1376             mPendingBroadcastRecvIndex = recIdx;
1377         }
1378     }
1379 
setBroadcastTimeoutLocked(long timeoutTime)1380     final void setBroadcastTimeoutLocked(long timeoutTime) {
1381         if (! mPendingBroadcastTimeoutMessage) {
1382             Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG, this);
1383             mHandler.sendMessageAtTime(msg, timeoutTime);
1384             mPendingBroadcastTimeoutMessage = true;
1385         }
1386     }
1387 
cancelBroadcastTimeoutLocked()1388     final void cancelBroadcastTimeoutLocked() {
1389         if (mPendingBroadcastTimeoutMessage) {
1390             mHandler.removeMessages(BROADCAST_TIMEOUT_MSG, this);
1391             mPendingBroadcastTimeoutMessage = false;
1392         }
1393     }
1394 
broadcastTimeoutLocked(boolean fromMsg)1395     final void broadcastTimeoutLocked(boolean fromMsg) {
1396         if (fromMsg) {
1397             mPendingBroadcastTimeoutMessage = false;
1398         }
1399 
1400         if (mOrderedBroadcasts.size() == 0) {
1401             return;
1402         }
1403 
1404         long now = SystemClock.uptimeMillis();
1405         BroadcastRecord r = mOrderedBroadcasts.get(0);
1406         if (fromMsg) {
1407             if (mService.mDidDexOpt) {
1408                 // Delay timeouts until dexopt finishes.
1409                 mService.mDidDexOpt = false;
1410                 long timeoutTime = SystemClock.uptimeMillis() + mTimeoutPeriod;
1411                 setBroadcastTimeoutLocked(timeoutTime);
1412                 return;
1413             }
1414             if (!mService.mProcessesReady) {
1415                 // Only process broadcast timeouts if the system is ready. That way
1416                 // PRE_BOOT_COMPLETED broadcasts can't timeout as they are intended
1417                 // to do heavy lifting for system up.
1418                 return;
1419             }
1420 
1421             long timeoutTime = r.receiverTime + mTimeoutPeriod;
1422             if (timeoutTime > now) {
1423                 // We can observe premature timeouts because we do not cancel and reset the
1424                 // broadcast timeout message after each receiver finishes.  Instead, we set up
1425                 // an initial timeout then kick it down the road a little further as needed
1426                 // when it expires.
1427                 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
1428                         "Premature timeout ["
1429                         + mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for "
1430                         + timeoutTime);
1431                 setBroadcastTimeoutLocked(timeoutTime);
1432                 return;
1433             }
1434         }
1435 
1436         BroadcastRecord br = mOrderedBroadcasts.get(0);
1437         if (br.state == BroadcastRecord.WAITING_SERVICES) {
1438             // In this case the broadcast had already finished, but we had decided to wait
1439             // for started services to finish as well before going on.  So if we have actually
1440             // waited long enough time timeout the broadcast, let's give up on the whole thing
1441             // and just move on to the next.
1442             Slog.i(TAG, "Waited long enough for: " + (br.curComponent != null
1443                     ? br.curComponent.flattenToShortString() : "(null)"));
1444             br.curComponent = null;
1445             br.state = BroadcastRecord.IDLE;
1446             processNextBroadcast(false);
1447             return;
1448         }
1449 
1450         Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r. receiver
1451                 + ", started " + (now - r.receiverTime) + "ms ago");
1452         r.receiverTime = now;
1453         r.anrCount++;
1454 
1455         // Current receiver has passed its expiration date.
1456         if (r.nextReceiver <= 0) {
1457             Slog.w(TAG, "Timeout on receiver with nextReceiver <= 0");
1458             return;
1459         }
1460 
1461         ProcessRecord app = null;
1462         String anrMessage = null;
1463 
1464         Object curReceiver = r.receivers.get(r.nextReceiver-1);
1465         r.delivery[r.nextReceiver-1] = BroadcastRecord.DELIVERY_TIMEOUT;
1466         Slog.w(TAG, "Receiver during timeout: " + curReceiver);
1467         logBroadcastReceiverDiscardLocked(r);
1468         if (curReceiver instanceof BroadcastFilter) {
1469             BroadcastFilter bf = (BroadcastFilter)curReceiver;
1470             if (bf.receiverList.pid != 0
1471                     && bf.receiverList.pid != ActivityManagerService.MY_PID) {
1472                 synchronized (mService.mPidsSelfLocked) {
1473                     app = mService.mPidsSelfLocked.get(
1474                             bf.receiverList.pid);
1475                 }
1476             }
1477         } else {
1478             app = r.curApp;
1479         }
1480 
1481         if (app != null) {
1482             anrMessage = "Broadcast of " + r.intent.toString();
1483         }
1484 
1485         if (mPendingBroadcast == r) {
1486             mPendingBroadcast = null;
1487         }
1488 
1489         // Move on to the next receiver.
1490         finishReceiverLocked(r, r.resultCode, r.resultData,
1491                 r.resultExtras, r.resultAbort, false);
1492         scheduleBroadcastsLocked();
1493 
1494         if (anrMessage != null) {
1495             // Post the ANR to the handler since we do not want to process ANRs while
1496             // potentially holding our lock.
1497             mHandler.post(new AppNotResponding(app, anrMessage));
1498         }
1499     }
1500 
ringAdvance(int x, final int increment, final int ringSize)1501     private final int ringAdvance(int x, final int increment, final int ringSize) {
1502         x += increment;
1503         if (x < 0) return (ringSize - 1);
1504         else if (x >= ringSize) return 0;
1505         else return x;
1506     }
1507 
addBroadcastToHistoryLocked(BroadcastRecord r)1508     private final void addBroadcastToHistoryLocked(BroadcastRecord r) {
1509         if (r.callingUid < 0) {
1510             // This was from a registerReceiver() call; ignore it.
1511             return;
1512         }
1513         r.finishTime = SystemClock.uptimeMillis();
1514 
1515         if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
1516             Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
1517                 createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
1518                 System.identityHashCode(r));
1519         }
1520 
1521         mBroadcastHistory[mHistoryNext] = r;
1522         mHistoryNext = ringAdvance(mHistoryNext, 1, MAX_BROADCAST_HISTORY);
1523 
1524         mBroadcastSummaryHistory[mSummaryHistoryNext] = r.intent;
1525         mSummaryHistoryEnqueueTime[mSummaryHistoryNext] = r.enqueueClockTime;
1526         mSummaryHistoryDispatchTime[mSummaryHistoryNext] = r.dispatchClockTime;
1527         mSummaryHistoryFinishTime[mSummaryHistoryNext] = System.currentTimeMillis();
1528         mSummaryHistoryNext = ringAdvance(mSummaryHistoryNext, 1, MAX_BROADCAST_SUMMARY_HISTORY);
1529     }
1530 
cleanupDisabledPackageReceiversLocked( String packageName, Set<String> filterByClasses, int userId, boolean doit)1531     boolean cleanupDisabledPackageReceiversLocked(
1532             String packageName, Set<String> filterByClasses, int userId, boolean doit) {
1533         boolean didSomething = false;
1534         for (int i = mParallelBroadcasts.size() - 1; i >= 0; i--) {
1535             didSomething |= mParallelBroadcasts.get(i).cleanupDisabledPackageReceiversLocked(
1536                     packageName, filterByClasses, userId, doit);
1537             if (!doit && didSomething) {
1538                 return true;
1539             }
1540         }
1541 
1542         for (int i = mOrderedBroadcasts.size() - 1; i >= 0; i--) {
1543             didSomething |= mOrderedBroadcasts.get(i).cleanupDisabledPackageReceiversLocked(
1544                     packageName, filterByClasses, userId, doit);
1545             if (!doit && didSomething) {
1546                 return true;
1547             }
1548         }
1549 
1550         return didSomething;
1551     }
1552 
logBroadcastReceiverDiscardLocked(BroadcastRecord r)1553     final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) {
1554         final int logIndex = r.nextReceiver - 1;
1555         if (logIndex >= 0 && logIndex < r.receivers.size()) {
1556             Object curReceiver = r.receivers.get(logIndex);
1557             if (curReceiver instanceof BroadcastFilter) {
1558                 BroadcastFilter bf = (BroadcastFilter) curReceiver;
1559                 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER,
1560                         bf.owningUserId, System.identityHashCode(r),
1561                         r.intent.getAction(), logIndex, System.identityHashCode(bf));
1562             } else {
1563                 ResolveInfo ri = (ResolveInfo) curReceiver;
1564                 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
1565                         UserHandle.getUserId(ri.activityInfo.applicationInfo.uid),
1566                         System.identityHashCode(r), r.intent.getAction(), logIndex, ri.toString());
1567             }
1568         } else {
1569             if (logIndex < 0) Slog.w(TAG,
1570                     "Discarding broadcast before first receiver is invoked: " + r);
1571             EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
1572                     -1, System.identityHashCode(r),
1573                     r.intent.getAction(),
1574                     r.nextReceiver,
1575                     "NONE");
1576         }
1577     }
1578 
createBroadcastTraceTitle(BroadcastRecord record, int state)1579     private String createBroadcastTraceTitle(BroadcastRecord record, int state) {
1580         return String.format("Broadcast %s from %s (%s) %s",
1581                 state == BroadcastRecord.DELIVERY_PENDING ? "in queue" : "dispatched",
1582                 record.callerPackage == null ? "" : record.callerPackage,
1583                 record.callerApp == null ? "process unknown" : record.callerApp.toShortString(),
1584                 record.intent == null ? "" : record.intent.getAction());
1585     }
1586 
isIdle()1587     final boolean isIdle() {
1588         return mParallelBroadcasts.isEmpty() && mOrderedBroadcasts.isEmpty()
1589                 && (mPendingBroadcast == null);
1590     }
1591 
dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, int opti, boolean dumpAll, String dumpPackage, boolean needSep)1592     final boolean dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args,
1593             int opti, boolean dumpAll, String dumpPackage, boolean needSep) {
1594         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
1595         if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0
1596                 || mPendingBroadcast != null) {
1597             boolean printed = false;
1598             for (int i = mParallelBroadcasts.size() - 1; i >= 0; i--) {
1599                 BroadcastRecord br = mParallelBroadcasts.get(i);
1600                 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) {
1601                     continue;
1602                 }
1603                 if (!printed) {
1604                     if (needSep) {
1605                         pw.println();
1606                     }
1607                     needSep = true;
1608                     printed = true;
1609                     pw.println("  Active broadcasts [" + mQueueName + "]:");
1610                 }
1611                 pw.println("  Active Broadcast " + mQueueName + " #" + i + ":");
1612                 br.dump(pw, "    ", sdf);
1613             }
1614             printed = false;
1615             needSep = true;
1616             for (int i = mOrderedBroadcasts.size() - 1; i >= 0; i--) {
1617                 BroadcastRecord br = mOrderedBroadcasts.get(i);
1618                 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) {
1619                     continue;
1620                 }
1621                 if (!printed) {
1622                     if (needSep) {
1623                         pw.println();
1624                     }
1625                     needSep = true;
1626                     printed = true;
1627                     pw.println("  Active ordered broadcasts [" + mQueueName + "]:");
1628                 }
1629                 pw.println("  Active Ordered Broadcast " + mQueueName + " #" + i + ":");
1630                 mOrderedBroadcasts.get(i).dump(pw, "    ", sdf);
1631             }
1632             if (dumpPackage == null || (mPendingBroadcast != null
1633                     && dumpPackage.equals(mPendingBroadcast.callerPackage))) {
1634                 if (needSep) {
1635                     pw.println();
1636                 }
1637                 pw.println("  Pending broadcast [" + mQueueName + "]:");
1638                 if (mPendingBroadcast != null) {
1639                     mPendingBroadcast.dump(pw, "    ", sdf);
1640                 } else {
1641                     pw.println("    (null)");
1642                 }
1643                 needSep = true;
1644             }
1645         }
1646 
1647         int i;
1648         boolean printed = false;
1649 
1650         i = -1;
1651         int lastIndex = mHistoryNext;
1652         int ringIndex = lastIndex;
1653         do {
1654             // increasing index = more recent entry, and we want to print the most
1655             // recent first and work backwards, so we roll through the ring backwards.
1656             ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
1657             BroadcastRecord r = mBroadcastHistory[ringIndex];
1658             if (r == null) {
1659                 continue;
1660             }
1661 
1662             i++; // genuine record of some sort even if we're filtering it out
1663             if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) {
1664                 continue;
1665             }
1666             if (!printed) {
1667                 if (needSep) {
1668                     pw.println();
1669                 }
1670                 needSep = true;
1671                 pw.println("  Historical broadcasts [" + mQueueName + "]:");
1672                 printed = true;
1673             }
1674             if (dumpAll) {
1675                 pw.print("  Historical Broadcast " + mQueueName + " #");
1676                         pw.print(i); pw.println(":");
1677                 r.dump(pw, "    ", sdf);
1678             } else {
1679                 pw.print("  #"); pw.print(i); pw.print(": "); pw.println(r);
1680                 pw.print("    ");
1681                 pw.println(r.intent.toShortString(false, true, true, false));
1682                 if (r.targetComp != null && r.targetComp != r.intent.getComponent()) {
1683                     pw.print("    targetComp: "); pw.println(r.targetComp.toShortString());
1684                 }
1685                 Bundle bundle = r.intent.getExtras();
1686                 if (bundle != null) {
1687                     pw.print("    extras: "); pw.println(bundle.toString());
1688                 }
1689             }
1690         } while (ringIndex != lastIndex);
1691 
1692         if (dumpPackage == null) {
1693             lastIndex = ringIndex = mSummaryHistoryNext;
1694             if (dumpAll) {
1695                 printed = false;
1696                 i = -1;
1697             } else {
1698                 // roll over the 'i' full dumps that have already been issued
1699                 for (int j = i;
1700                         j > 0 && ringIndex != lastIndex;) {
1701                     ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
1702                     BroadcastRecord r = mBroadcastHistory[ringIndex];
1703                     if (r == null) {
1704                         continue;
1705                     }
1706                     j--;
1707                 }
1708             }
1709             // done skipping; dump the remainder of the ring. 'i' is still the ordinal within
1710             // the overall broadcast history.
1711             do {
1712                 ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
1713                 Intent intent = mBroadcastSummaryHistory[ringIndex];
1714                 if (intent == null) {
1715                     continue;
1716                 }
1717                 if (!printed) {
1718                     if (needSep) {
1719                         pw.println();
1720                     }
1721                     needSep = true;
1722                     pw.println("  Historical broadcasts summary [" + mQueueName + "]:");
1723                     printed = true;
1724                 }
1725                 if (!dumpAll && i >= 50) {
1726                     pw.println("  ...");
1727                     break;
1728                 }
1729                 i++;
1730                 pw.print("  #"); pw.print(i); pw.print(": ");
1731                 pw.println(intent.toShortString(false, true, true, false));
1732                 pw.print("    ");
1733                 TimeUtils.formatDuration(mSummaryHistoryDispatchTime[ringIndex]
1734                         - mSummaryHistoryEnqueueTime[ringIndex], pw);
1735                 pw.print(" dispatch ");
1736                 TimeUtils.formatDuration(mSummaryHistoryFinishTime[ringIndex]
1737                         - mSummaryHistoryDispatchTime[ringIndex], pw);
1738                 pw.println(" finish");
1739                 pw.print("    enq=");
1740                 pw.print(sdf.format(new Date(mSummaryHistoryEnqueueTime[ringIndex])));
1741                 pw.print(" disp=");
1742                 pw.print(sdf.format(new Date(mSummaryHistoryDispatchTime[ringIndex])));
1743                 pw.print(" fin=");
1744                 pw.println(sdf.format(new Date(mSummaryHistoryFinishTime[ringIndex])));
1745                 Bundle bundle = intent.getExtras();
1746                 if (bundle != null) {
1747                     pw.print("    extras: "); pw.println(bundle.toString());
1748                 }
1749             } while (ringIndex != lastIndex);
1750         }
1751 
1752         return needSep;
1753     }
1754 }
1755