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 java.io.FileDescriptor; 20 import java.io.PrintWriter; 21 import java.util.ArrayList; 22 23 import android.app.ActivityManager; 24 import android.app.AppGlobals; 25 import android.app.AppOpsManager; 26 import android.content.ComponentName; 27 import android.content.IIntentReceiver; 28 import android.content.Intent; 29 import android.content.pm.ActivityInfo; 30 import android.content.pm.ApplicationInfo; 31 import android.content.pm.PackageManager; 32 import android.content.pm.ResolveInfo; 33 import android.os.Bundle; 34 import android.os.Handler; 35 import android.os.IBinder; 36 import android.os.Looper; 37 import android.os.Message; 38 import android.os.Process; 39 import android.os.RemoteException; 40 import android.os.SystemClock; 41 import android.os.UserHandle; 42 import android.util.EventLog; 43 import android.util.Log; 44 import android.util.Slog; 45 46 /** 47 * BROADCASTS 48 * 49 * We keep two broadcast queues and associated bookkeeping, one for those at 50 * foreground priority, and one for normal (background-priority) broadcasts. 51 */ 52 public final class BroadcastQueue { 53 static final String TAG = "BroadcastQueue"; 54 static final String TAG_MU = ActivityManagerService.TAG_MU; 55 static final boolean DEBUG_BROADCAST = ActivityManagerService.DEBUG_BROADCAST; 56 static final boolean DEBUG_BROADCAST_LIGHT = ActivityManagerService.DEBUG_BROADCAST_LIGHT; 57 static final boolean DEBUG_MU = ActivityManagerService.DEBUG_MU; 58 59 static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50; 60 static final int MAX_BROADCAST_SUMMARY_HISTORY 61 = ActivityManager.isLowRamDeviceStatic() ? 25 : 300; 62 63 final ActivityManagerService mService; 64 65 /** 66 * Recognizable moniker for this queue 67 */ 68 final String mQueueName; 69 70 /** 71 * Timeout period for this queue's broadcasts 72 */ 73 final long mTimeoutPeriod; 74 75 /** 76 * If true, we can delay broadcasts while waiting services to finish in the previous 77 * receiver's process. 78 */ 79 final boolean mDelayBehindServices; 80 81 /** 82 * Lists of all active broadcasts that are to be executed immediately 83 * (without waiting for another broadcast to finish). Currently this only 84 * contains broadcasts to registered receivers, to avoid spinning up 85 * a bunch of processes to execute IntentReceiver components. Background- 86 * and foreground-priority broadcasts are queued separately. 87 */ 88 final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<BroadcastRecord>(); 89 90 /** 91 * List of all active broadcasts that are to be executed one at a time. 92 * The object at the top of the list is the currently activity broadcasts; 93 * those after it are waiting for the top to finish. As with parallel 94 * broadcasts, separate background- and foreground-priority queues are 95 * maintained. 96 */ 97 final ArrayList<BroadcastRecord> mOrderedBroadcasts = new ArrayList<BroadcastRecord>(); 98 99 /** 100 * Historical data of past broadcasts, for debugging. 101 */ 102 final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY]; 103 104 /** 105 * Summary of historical data of past broadcasts, for debugging. 106 */ 107 final Intent[] mBroadcastSummaryHistory = new Intent[MAX_BROADCAST_SUMMARY_HISTORY]; 108 109 /** 110 * Set when we current have a BROADCAST_INTENT_MSG in flight. 111 */ 112 boolean mBroadcastsScheduled = false; 113 114 /** 115 * True if we have a pending unexpired BROADCAST_TIMEOUT_MSG posted to our handler. 116 */ 117 boolean mPendingBroadcastTimeoutMessage; 118 119 /** 120 * Intent broadcasts that we have tried to start, but are 121 * waiting for the application's process to be created. We only 122 * need one per scheduling class (instead of a list) because we always 123 * process broadcasts one at a time, so no others can be started while 124 * waiting for this one. 125 */ 126 BroadcastRecord mPendingBroadcast = null; 127 128 /** 129 * The receiver index that is pending, to restart the broadcast if needed. 130 */ 131 int mPendingBroadcastRecvIndex; 132 133 static final int BROADCAST_INTENT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG; 134 static final int BROADCAST_TIMEOUT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG + 1; 135 136 final BroadcastHandler mHandler; 137 138 private final class BroadcastHandler extends Handler { BroadcastHandler(Looper looper)139 public BroadcastHandler(Looper looper) { 140 super(looper, null, true); 141 } 142 143 @Override handleMessage(Message msg)144 public void handleMessage(Message msg) { 145 switch (msg.what) { 146 case BROADCAST_INTENT_MSG: { 147 if (DEBUG_BROADCAST) Slog.v( 148 TAG, "Received BROADCAST_INTENT_MSG"); 149 processNextBroadcast(true); 150 } break; 151 case BROADCAST_TIMEOUT_MSG: { 152 synchronized (mService) { 153 broadcastTimeoutLocked(true); 154 } 155 } break; 156 } 157 } 158 }; 159 160 private final class AppNotResponding implements Runnable { 161 private final ProcessRecord mApp; 162 private final String mAnnotation; 163 AppNotResponding(ProcessRecord app, String annotation)164 public AppNotResponding(ProcessRecord app, String annotation) { 165 mApp = app; 166 mAnnotation = annotation; 167 } 168 169 @Override run()170 public void run() { 171 mService.appNotResponding(mApp, null, null, false, mAnnotation); 172 } 173 } 174 BroadcastQueue(ActivityManagerService service, Handler handler, String name, long timeoutPeriod, boolean allowDelayBehindServices)175 BroadcastQueue(ActivityManagerService service, Handler handler, 176 String name, long timeoutPeriod, boolean allowDelayBehindServices) { 177 mService = service; 178 mHandler = new BroadcastHandler(handler.getLooper()); 179 mQueueName = name; 180 mTimeoutPeriod = timeoutPeriod; 181 mDelayBehindServices = allowDelayBehindServices; 182 } 183 isPendingBroadcastProcessLocked(int pid)184 public boolean isPendingBroadcastProcessLocked(int pid) { 185 return mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid; 186 } 187 enqueueParallelBroadcastLocked(BroadcastRecord r)188 public void enqueueParallelBroadcastLocked(BroadcastRecord r) { 189 mParallelBroadcasts.add(r); 190 } 191 enqueueOrderedBroadcastLocked(BroadcastRecord r)192 public void enqueueOrderedBroadcastLocked(BroadcastRecord r) { 193 mOrderedBroadcasts.add(r); 194 } 195 replaceParallelBroadcastLocked(BroadcastRecord r)196 public final boolean replaceParallelBroadcastLocked(BroadcastRecord r) { 197 for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { 198 if (r.intent.filterEquals(mParallelBroadcasts.get(i).intent)) { 199 if (DEBUG_BROADCAST) Slog.v(TAG, 200 "***** DROPPING PARALLEL [" 201 + mQueueName + "]: " + r.intent); 202 mParallelBroadcasts.set(i, r); 203 return true; 204 } 205 } 206 return false; 207 } 208 replaceOrderedBroadcastLocked(BroadcastRecord r)209 public final boolean replaceOrderedBroadcastLocked(BroadcastRecord r) { 210 for (int i=mOrderedBroadcasts.size()-1; i>0; i--) { 211 if (r.intent.filterEquals(mOrderedBroadcasts.get(i).intent)) { 212 if (DEBUG_BROADCAST) Slog.v(TAG, 213 "***** DROPPING ORDERED [" 214 + mQueueName + "]: " + r.intent); 215 mOrderedBroadcasts.set(i, r); 216 return true; 217 } 218 } 219 return false; 220 } 221 processCurBroadcastLocked(BroadcastRecord r, ProcessRecord app)222 private final void processCurBroadcastLocked(BroadcastRecord r, 223 ProcessRecord app) throws RemoteException { 224 if (DEBUG_BROADCAST) Slog.v(TAG, 225 "Process cur broadcast " + r + " for app " + app); 226 if (app.thread == null) { 227 throw new RemoteException(); 228 } 229 r.receiver = app.thread.asBinder(); 230 r.curApp = app; 231 app.curReceiver = r; 232 app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_RECEIVER); 233 mService.updateLruProcessLocked(app, false, null); 234 mService.updateOomAdjLocked(); 235 236 // Tell the application to launch this receiver. 237 r.intent.setComponent(r.curComponent); 238 239 boolean started = false; 240 try { 241 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, 242 "Delivering to component " + r.curComponent 243 + ": " + r); 244 mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName()); 245 app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver, 246 mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo), 247 r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId, 248 app.repProcState); 249 if (DEBUG_BROADCAST) Slog.v(TAG, 250 "Process cur broadcast " + r + " DELIVERED for app " + app); 251 started = true; 252 } finally { 253 if (!started) { 254 if (DEBUG_BROADCAST) Slog.v(TAG, 255 "Process cur broadcast " + r + ": NOT STARTED!"); 256 r.receiver = null; 257 r.curApp = null; 258 app.curReceiver = null; 259 } 260 } 261 } 262 sendPendingBroadcastsLocked(ProcessRecord app)263 public boolean sendPendingBroadcastsLocked(ProcessRecord app) { 264 boolean didSomething = false; 265 final BroadcastRecord br = mPendingBroadcast; 266 if (br != null && br.curApp.pid == app.pid) { 267 try { 268 mPendingBroadcast = null; 269 processCurBroadcastLocked(br, app); 270 didSomething = true; 271 } catch (Exception e) { 272 Slog.w(TAG, "Exception in new application when starting receiver " 273 + br.curComponent.flattenToShortString(), e); 274 logBroadcastReceiverDiscardLocked(br); 275 finishReceiverLocked(br, br.resultCode, br.resultData, 276 br.resultExtras, br.resultAbort, false); 277 scheduleBroadcastsLocked(); 278 // We need to reset the state if we failed to start the receiver. 279 br.state = BroadcastRecord.IDLE; 280 throw new RuntimeException(e.getMessage()); 281 } 282 } 283 return didSomething; 284 } 285 skipPendingBroadcastLocked(int pid)286 public void skipPendingBroadcastLocked(int pid) { 287 final BroadcastRecord br = mPendingBroadcast; 288 if (br != null && br.curApp.pid == pid) { 289 br.state = BroadcastRecord.IDLE; 290 br.nextReceiver = mPendingBroadcastRecvIndex; 291 mPendingBroadcast = null; 292 scheduleBroadcastsLocked(); 293 } 294 } 295 skipCurrentReceiverLocked(ProcessRecord app)296 public void skipCurrentReceiverLocked(ProcessRecord app) { 297 boolean reschedule = false; 298 BroadcastRecord r = app.curReceiver; 299 if (r != null && r.queue == this) { 300 // The current broadcast is waiting for this app's receiver 301 // to be finished. Looks like that's not going to happen, so 302 // let the broadcast continue. 303 logBroadcastReceiverDiscardLocked(r); 304 finishReceiverLocked(r, r.resultCode, r.resultData, 305 r.resultExtras, r.resultAbort, false); 306 reschedule = true; 307 } 308 309 r = mPendingBroadcast; 310 if (r != null && r.curApp == app) { 311 if (DEBUG_BROADCAST) Slog.v(TAG, 312 "[" + mQueueName + "] skip & discard pending app " + r); 313 logBroadcastReceiverDiscardLocked(r); 314 finishReceiverLocked(r, r.resultCode, r.resultData, 315 r.resultExtras, r.resultAbort, false); 316 reschedule = true; 317 } 318 if (reschedule) { 319 scheduleBroadcastsLocked(); 320 } 321 } 322 scheduleBroadcastsLocked()323 public void scheduleBroadcastsLocked() { 324 if (DEBUG_BROADCAST) Slog.v(TAG, "Schedule broadcasts [" 325 + mQueueName + "]: current=" 326 + mBroadcastsScheduled); 327 328 if (mBroadcastsScheduled) { 329 return; 330 } 331 mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this)); 332 mBroadcastsScheduled = true; 333 } 334 getMatchingOrderedReceiver(IBinder receiver)335 public BroadcastRecord getMatchingOrderedReceiver(IBinder receiver) { 336 if (mOrderedBroadcasts.size() > 0) { 337 final BroadcastRecord r = mOrderedBroadcasts.get(0); 338 if (r != null && r.receiver == receiver) { 339 return r; 340 } 341 } 342 return null; 343 } 344 finishReceiverLocked(BroadcastRecord r, int resultCode, String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices)345 public boolean finishReceiverLocked(BroadcastRecord r, int resultCode, 346 String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices) { 347 final int state = r.state; 348 final ActivityInfo receiver = r.curReceiver; 349 r.state = BroadcastRecord.IDLE; 350 if (state == BroadcastRecord.IDLE) { 351 Slog.w(TAG, "finishReceiver [" + mQueueName + "] called but state is IDLE"); 352 } 353 r.receiver = null; 354 r.intent.setComponent(null); 355 if (r.curApp != null && r.curApp.curReceiver == r) { 356 r.curApp.curReceiver = null; 357 } 358 if (r.curFilter != null) { 359 r.curFilter.receiverList.curBroadcast = null; 360 } 361 r.curFilter = null; 362 r.curReceiver = null; 363 r.curApp = null; 364 mPendingBroadcast = null; 365 366 r.resultCode = resultCode; 367 r.resultData = resultData; 368 r.resultExtras = resultExtras; 369 if (resultAbort && (r.intent.getFlags()&Intent.FLAG_RECEIVER_NO_ABORT) == 0) { 370 r.resultAbort = resultAbort; 371 } else { 372 r.resultAbort = false; 373 } 374 375 if (waitForServices && r.curComponent != null && r.queue.mDelayBehindServices 376 && r.queue.mOrderedBroadcasts.size() > 0 377 && r.queue.mOrderedBroadcasts.get(0) == r) { 378 ActivityInfo nextReceiver; 379 if (r.nextReceiver < r.receivers.size()) { 380 Object obj = r.receivers.get(r.nextReceiver); 381 nextReceiver = (obj instanceof ActivityInfo) ? (ActivityInfo)obj : null; 382 } else { 383 nextReceiver = null; 384 } 385 // Don't do this if the next receive is in the same process as the current one. 386 if (receiver == null || nextReceiver == null 387 || receiver.applicationInfo.uid != nextReceiver.applicationInfo.uid 388 || !receiver.processName.equals(nextReceiver.processName)) { 389 // In this case, we are ready to process the next receiver for the current broadcast, 390 // but are on a queue that would like to wait for services to finish before moving 391 // on. If there are background services currently starting, then we will go into a 392 // special state where we hold off on continuing this broadcast until they are done. 393 if (mService.mServices.hasBackgroundServices(r.userId)) { 394 Slog.i(ActivityManagerService.TAG, "Delay finish: " 395 + r.curComponent.flattenToShortString()); 396 r.state = BroadcastRecord.WAITING_SERVICES; 397 return false; 398 } 399 } 400 } 401 402 r.curComponent = null; 403 404 // We will process the next receiver right now if this is finishing 405 // an app receiver (which is always asynchronous) or after we have 406 // come back from calling a receiver. 407 return state == BroadcastRecord.APP_RECEIVE 408 || state == BroadcastRecord.CALL_DONE_RECEIVE; 409 } 410 backgroundServicesFinishedLocked(int userId)411 public void backgroundServicesFinishedLocked(int userId) { 412 if (mOrderedBroadcasts.size() > 0) { 413 BroadcastRecord br = mOrderedBroadcasts.get(0); 414 if (br.userId == userId && br.state == BroadcastRecord.WAITING_SERVICES) { 415 Slog.i(ActivityManagerService.TAG, "Resuming delayed broadcast"); 416 br.curComponent = null; 417 br.state = BroadcastRecord.IDLE; 418 processNextBroadcast(false); 419 } 420 } 421 } 422 performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser)423 private static void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver, 424 Intent intent, int resultCode, String data, Bundle extras, 425 boolean ordered, boolean sticky, int sendingUser) throws RemoteException { 426 // Send the intent to the receiver asynchronously using one-way binder calls. 427 if (app != null) { 428 if (app.thread != null) { 429 // If we have an app thread, do the call through that so it is 430 // correctly ordered with other one-way calls. 431 app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode, 432 data, extras, ordered, sticky, sendingUser, app.repProcState); 433 } else { 434 // Application has died. Receiver doesn't exist. 435 throw new RemoteException("app.thread must not be null"); 436 } 437 } else { 438 receiver.performReceive(intent, resultCode, data, extras, ordered, 439 sticky, sendingUser); 440 } 441 } 442 deliverToRegisteredReceiverLocked(BroadcastRecord r, BroadcastFilter filter, boolean ordered)443 private final void deliverToRegisteredReceiverLocked(BroadcastRecord r, 444 BroadcastFilter filter, boolean ordered) { 445 boolean skip = false; 446 if (filter.requiredPermission != null) { 447 int perm = mService.checkComponentPermission(filter.requiredPermission, 448 r.callingPid, r.callingUid, -1, true); 449 if (perm != PackageManager.PERMISSION_GRANTED) { 450 Slog.w(TAG, "Permission Denial: broadcasting " 451 + r.intent.toString() 452 + " from " + r.callerPackage + " (pid=" 453 + r.callingPid + ", uid=" + r.callingUid + ")" 454 + " requires " + filter.requiredPermission 455 + " due to registered receiver " + filter); 456 skip = true; 457 } 458 } 459 if (!skip && r.requiredPermission != null) { 460 int perm = mService.checkComponentPermission(r.requiredPermission, 461 filter.receiverList.pid, filter.receiverList.uid, -1, true); 462 if (perm != PackageManager.PERMISSION_GRANTED) { 463 Slog.w(TAG, "Permission Denial: receiving " 464 + r.intent.toString() 465 + " to " + filter.receiverList.app 466 + " (pid=" + filter.receiverList.pid 467 + ", uid=" + filter.receiverList.uid + ")" 468 + " requires " + r.requiredPermission 469 + " due to sender " + r.callerPackage 470 + " (uid " + r.callingUid + ")"); 471 skip = true; 472 } 473 } 474 if (r.appOp != AppOpsManager.OP_NONE) { 475 int mode = mService.mAppOpsService.noteOperation(r.appOp, 476 filter.receiverList.uid, filter.packageName); 477 if (mode != AppOpsManager.MODE_ALLOWED) { 478 if (DEBUG_BROADCAST) Slog.v(TAG, 479 "App op " + r.appOp + " not allowed for broadcast to uid " 480 + filter.receiverList.uid + " pkg " + filter.packageName); 481 skip = true; 482 } 483 } 484 if (!skip) { 485 skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid, 486 r.callingPid, r.resolvedType, filter.receiverList.uid); 487 } 488 489 if (filter.receiverList.app == null || filter.receiverList.app.crashing) { 490 Slog.w(TAG, "Skipping deliver [" + mQueueName + "] " + r 491 + " to " + filter.receiverList + ": process crashing"); 492 skip = true; 493 } 494 495 if (!skip) { 496 // If this is not being sent as an ordered broadcast, then we 497 // don't want to touch the fields that keep track of the current 498 // state of ordered broadcasts. 499 if (ordered) { 500 r.receiver = filter.receiverList.receiver.asBinder(); 501 r.curFilter = filter; 502 filter.receiverList.curBroadcast = r; 503 r.state = BroadcastRecord.CALL_IN_RECEIVE; 504 if (filter.receiverList.app != null) { 505 // Bump hosting application to no longer be in background 506 // scheduling class. Note that we can't do that if there 507 // isn't an app... but we can only be in that case for 508 // things that directly call the IActivityManager API, which 509 // are already core system stuff so don't matter for this. 510 r.curApp = filter.receiverList.app; 511 filter.receiverList.app.curReceiver = r; 512 mService.updateOomAdjLocked(r.curApp); 513 } 514 } 515 try { 516 if (DEBUG_BROADCAST_LIGHT) { 517 int seq = r.intent.getIntExtra("seq", -1); 518 Slog.i(TAG, "Delivering to " + filter 519 + " (seq=" + seq + "): " + r); 520 } 521 performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver, 522 new Intent(r.intent), r.resultCode, r.resultData, 523 r.resultExtras, r.ordered, r.initialSticky, r.userId); 524 if (ordered) { 525 r.state = BroadcastRecord.CALL_DONE_RECEIVE; 526 } 527 } catch (RemoteException e) { 528 Slog.w(TAG, "Failure sending broadcast " + r.intent, e); 529 if (ordered) { 530 r.receiver = null; 531 r.curFilter = null; 532 filter.receiverList.curBroadcast = null; 533 if (filter.receiverList.app != null) { 534 filter.receiverList.app.curReceiver = null; 535 } 536 } 537 } 538 } 539 } 540 processNextBroadcast(boolean fromMsg)541 final void processNextBroadcast(boolean fromMsg) { 542 synchronized(mService) { 543 BroadcastRecord r; 544 545 if (DEBUG_BROADCAST) Slog.v(TAG, "processNextBroadcast [" 546 + mQueueName + "]: " 547 + mParallelBroadcasts.size() + " broadcasts, " 548 + mOrderedBroadcasts.size() + " ordered broadcasts"); 549 550 mService.updateCpuStats(); 551 552 if (fromMsg) { 553 mBroadcastsScheduled = false; 554 } 555 556 // First, deliver any non-serialized broadcasts right away. 557 while (mParallelBroadcasts.size() > 0) { 558 r = mParallelBroadcasts.remove(0); 559 r.dispatchTime = SystemClock.uptimeMillis(); 560 r.dispatchClockTime = System.currentTimeMillis(); 561 final int N = r.receivers.size(); 562 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing parallel broadcast [" 563 + mQueueName + "] " + r); 564 for (int i=0; i<N; i++) { 565 Object target = r.receivers.get(i); 566 if (DEBUG_BROADCAST) Slog.v(TAG, 567 "Delivering non-ordered on [" + mQueueName + "] to registered " 568 + target + ": " + r); 569 deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false); 570 } 571 addBroadcastToHistoryLocked(r); 572 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Done with parallel broadcast [" 573 + mQueueName + "] " + r); 574 } 575 576 // Now take care of the next serialized one... 577 578 // If we are waiting for a process to come up to handle the next 579 // broadcast, then do nothing at this point. Just in case, we 580 // check that the process we're waiting for still exists. 581 if (mPendingBroadcast != null) { 582 if (DEBUG_BROADCAST_LIGHT) { 583 Slog.v(TAG, "processNextBroadcast [" 584 + mQueueName + "]: waiting for " 585 + mPendingBroadcast.curApp); 586 } 587 588 boolean isDead; 589 synchronized (mService.mPidsSelfLocked) { 590 ProcessRecord proc = mService.mPidsSelfLocked.get(mPendingBroadcast.curApp.pid); 591 isDead = proc == null || proc.crashing; 592 } 593 if (!isDead) { 594 // It's still alive, so keep waiting 595 return; 596 } else { 597 Slog.w(TAG, "pending app [" 598 + mQueueName + "]" + mPendingBroadcast.curApp 599 + " died before responding to broadcast"); 600 mPendingBroadcast.state = BroadcastRecord.IDLE; 601 mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex; 602 mPendingBroadcast = null; 603 } 604 } 605 606 boolean looped = false; 607 608 do { 609 if (mOrderedBroadcasts.size() == 0) { 610 // No more broadcasts pending, so all done! 611 mService.scheduleAppGcsLocked(); 612 if (looped) { 613 // If we had finished the last ordered broadcast, then 614 // make sure all processes have correct oom and sched 615 // adjustments. 616 mService.updateOomAdjLocked(); 617 } 618 return; 619 } 620 r = mOrderedBroadcasts.get(0); 621 boolean forceReceive = false; 622 623 // Ensure that even if something goes awry with the timeout 624 // detection, we catch "hung" broadcasts here, discard them, 625 // and continue to make progress. 626 // 627 // This is only done if the system is ready so that PRE_BOOT_COMPLETED 628 // receivers don't get executed with timeouts. They're intended for 629 // one time heavy lifting after system upgrades and can take 630 // significant amounts of time. 631 int numReceivers = (r.receivers != null) ? r.receivers.size() : 0; 632 if (mService.mProcessesReady && r.dispatchTime > 0) { 633 long now = SystemClock.uptimeMillis(); 634 if ((numReceivers > 0) && 635 (now > r.dispatchTime + (2*mTimeoutPeriod*numReceivers))) { 636 Slog.w(TAG, "Hung broadcast [" 637 + mQueueName + "] discarded after timeout failure:" 638 + " now=" + now 639 + " dispatchTime=" + r.dispatchTime 640 + " startTime=" + r.receiverTime 641 + " intent=" + r.intent 642 + " numReceivers=" + numReceivers 643 + " nextReceiver=" + r.nextReceiver 644 + " state=" + r.state); 645 broadcastTimeoutLocked(false); // forcibly finish this broadcast 646 forceReceive = true; 647 r.state = BroadcastRecord.IDLE; 648 } 649 } 650 651 if (r.state != BroadcastRecord.IDLE) { 652 if (DEBUG_BROADCAST) Slog.d(TAG, 653 "processNextBroadcast(" 654 + mQueueName + ") called when not idle (state=" 655 + r.state + ")"); 656 return; 657 } 658 659 if (r.receivers == null || r.nextReceiver >= numReceivers 660 || r.resultAbort || forceReceive) { 661 // No more receivers for this broadcast! Send the final 662 // result if requested... 663 if (r.resultTo != null) { 664 try { 665 if (DEBUG_BROADCAST) { 666 int seq = r.intent.getIntExtra("seq", -1); 667 Slog.i(TAG, "Finishing broadcast [" 668 + mQueueName + "] " + r.intent.getAction() 669 + " seq=" + seq + " app=" + r.callerApp); 670 } 671 performReceiveLocked(r.callerApp, r.resultTo, 672 new Intent(r.intent), r.resultCode, 673 r.resultData, r.resultExtras, false, false, r.userId); 674 // Set this to null so that the reference 675 // (local and remote) isn't kept in the mBroadcastHistory. 676 r.resultTo = null; 677 } catch (RemoteException e) { 678 r.resultTo = null; 679 Slog.w(TAG, "Failure [" 680 + mQueueName + "] sending broadcast result of " 681 + r.intent, e); 682 } 683 } 684 685 if (DEBUG_BROADCAST) Slog.v(TAG, "Cancelling BROADCAST_TIMEOUT_MSG"); 686 cancelBroadcastTimeoutLocked(); 687 688 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Finished with ordered broadcast " 689 + r); 690 691 // ... and on to the next... 692 addBroadcastToHistoryLocked(r); 693 mOrderedBroadcasts.remove(0); 694 r = null; 695 looped = true; 696 continue; 697 } 698 } while (r == null); 699 700 // Get the next receiver... 701 int recIdx = r.nextReceiver++; 702 703 // Keep track of when this receiver started, and make sure there 704 // is a timeout message pending to kill it if need be. 705 r.receiverTime = SystemClock.uptimeMillis(); 706 if (recIdx == 0) { 707 r.dispatchTime = r.receiverTime; 708 r.dispatchClockTime = System.currentTimeMillis(); 709 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing ordered broadcast [" 710 + mQueueName + "] " + r); 711 } 712 if (! mPendingBroadcastTimeoutMessage) { 713 long timeoutTime = r.receiverTime + mTimeoutPeriod; 714 if (DEBUG_BROADCAST) Slog.v(TAG, 715 "Submitting BROADCAST_TIMEOUT_MSG [" 716 + mQueueName + "] for " + r + " at " + timeoutTime); 717 setBroadcastTimeoutLocked(timeoutTime); 718 } 719 720 Object nextReceiver = r.receivers.get(recIdx); 721 if (nextReceiver instanceof BroadcastFilter) { 722 // Simple case: this is a registered receiver who gets 723 // a direct call. 724 BroadcastFilter filter = (BroadcastFilter)nextReceiver; 725 if (DEBUG_BROADCAST) Slog.v(TAG, 726 "Delivering ordered [" 727 + mQueueName + "] to registered " 728 + filter + ": " + r); 729 deliverToRegisteredReceiverLocked(r, filter, r.ordered); 730 if (r.receiver == null || !r.ordered) { 731 // The receiver has already finished, so schedule to 732 // process the next one. 733 if (DEBUG_BROADCAST) Slog.v(TAG, "Quick finishing [" 734 + mQueueName + "]: ordered=" 735 + r.ordered + " receiver=" + r.receiver); 736 r.state = BroadcastRecord.IDLE; 737 scheduleBroadcastsLocked(); 738 } 739 return; 740 } 741 742 // Hard case: need to instantiate the receiver, possibly 743 // starting its application process to host it. 744 745 ResolveInfo info = 746 (ResolveInfo)nextReceiver; 747 ComponentName component = new ComponentName( 748 info.activityInfo.applicationInfo.packageName, 749 info.activityInfo.name); 750 751 boolean skip = false; 752 int perm = mService.checkComponentPermission(info.activityInfo.permission, 753 r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid, 754 info.activityInfo.exported); 755 if (perm != PackageManager.PERMISSION_GRANTED) { 756 if (!info.activityInfo.exported) { 757 Slog.w(TAG, "Permission Denial: broadcasting " 758 + r.intent.toString() 759 + " from " + r.callerPackage + " (pid=" + r.callingPid 760 + ", uid=" + r.callingUid + ")" 761 + " is not exported from uid " + info.activityInfo.applicationInfo.uid 762 + " due to receiver " + component.flattenToShortString()); 763 } else { 764 Slog.w(TAG, "Permission Denial: broadcasting " 765 + r.intent.toString() 766 + " from " + r.callerPackage + " (pid=" + r.callingPid 767 + ", uid=" + r.callingUid + ")" 768 + " requires " + info.activityInfo.permission 769 + " due to receiver " + component.flattenToShortString()); 770 } 771 skip = true; 772 } 773 if (info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID && 774 r.requiredPermission != null) { 775 try { 776 perm = AppGlobals.getPackageManager(). 777 checkPermission(r.requiredPermission, 778 info.activityInfo.applicationInfo.packageName); 779 } catch (RemoteException e) { 780 perm = PackageManager.PERMISSION_DENIED; 781 } 782 if (perm != PackageManager.PERMISSION_GRANTED) { 783 Slog.w(TAG, "Permission Denial: receiving " 784 + r.intent + " to " 785 + component.flattenToShortString() 786 + " requires " + r.requiredPermission 787 + " due to sender " + r.callerPackage 788 + " (uid " + r.callingUid + ")"); 789 skip = true; 790 } 791 } 792 if (r.appOp != AppOpsManager.OP_NONE) { 793 int mode = mService.mAppOpsService.noteOperation(r.appOp, 794 info.activityInfo.applicationInfo.uid, info.activityInfo.packageName); 795 if (mode != AppOpsManager.MODE_ALLOWED) { 796 if (DEBUG_BROADCAST) Slog.v(TAG, 797 "App op " + r.appOp + " not allowed for broadcast to uid " 798 + info.activityInfo.applicationInfo.uid + " pkg " 799 + info.activityInfo.packageName); 800 skip = true; 801 } 802 } 803 if (!skip) { 804 skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid, 805 r.callingPid, r.resolvedType, info.activityInfo.applicationInfo.uid); 806 } 807 boolean isSingleton = false; 808 try { 809 isSingleton = mService.isSingleton(info.activityInfo.processName, 810 info.activityInfo.applicationInfo, 811 info.activityInfo.name, info.activityInfo.flags); 812 } catch (SecurityException e) { 813 Slog.w(TAG, e.getMessage()); 814 skip = true; 815 } 816 if ((info.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) { 817 if (ActivityManager.checkUidPermission( 818 android.Manifest.permission.INTERACT_ACROSS_USERS, 819 info.activityInfo.applicationInfo.uid) 820 != PackageManager.PERMISSION_GRANTED) { 821 Slog.w(TAG, "Permission Denial: Receiver " + component.flattenToShortString() 822 + " requests FLAG_SINGLE_USER, but app does not hold " 823 + android.Manifest.permission.INTERACT_ACROSS_USERS); 824 skip = true; 825 } 826 } 827 if (r.curApp != null && r.curApp.crashing) { 828 // If the target process is crashing, just skip it. 829 Slog.w(TAG, "Skipping deliver ordered [" + mQueueName + "] " + r 830 + " to " + r.curApp + ": process crashing"); 831 skip = true; 832 } 833 if (!skip) { 834 boolean isAvailable = false; 835 try { 836 isAvailable = AppGlobals.getPackageManager().isPackageAvailable( 837 info.activityInfo.packageName, 838 UserHandle.getUserId(info.activityInfo.applicationInfo.uid)); 839 } catch (Exception e) { 840 // all such failures mean we skip this receiver 841 Slog.w(TAG, "Exception getting recipient info for " 842 + info.activityInfo.packageName, e); 843 } 844 if (!isAvailable) { 845 if (DEBUG_BROADCAST) { 846 Slog.v(TAG, "Skipping delivery to " + info.activityInfo.packageName 847 + " / " + info.activityInfo.applicationInfo.uid 848 + " : package no longer available"); 849 } 850 skip = true; 851 } 852 } 853 854 if (skip) { 855 if (DEBUG_BROADCAST) Slog.v(TAG, 856 "Skipping delivery of ordered [" 857 + mQueueName + "] " + r + " for whatever reason"); 858 r.receiver = null; 859 r.curFilter = null; 860 r.state = BroadcastRecord.IDLE; 861 scheduleBroadcastsLocked(); 862 return; 863 } 864 865 r.state = BroadcastRecord.APP_RECEIVE; 866 String targetProcess = info.activityInfo.processName; 867 r.curComponent = component; 868 final int receiverUid = info.activityInfo.applicationInfo.uid; 869 // If it's a singleton, it needs to be the same app or a special app 870 if (r.callingUid != Process.SYSTEM_UID && isSingleton 871 && mService.isValidSingletonCall(r.callingUid, receiverUid)) { 872 info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0); 873 } 874 r.curReceiver = info.activityInfo; 875 if (DEBUG_MU && r.callingUid > UserHandle.PER_USER_RANGE) { 876 Slog.v(TAG_MU, "Updated broadcast record activity info for secondary user, " 877 + info.activityInfo + ", callingUid = " + r.callingUid + ", uid = " 878 + info.activityInfo.applicationInfo.uid); 879 } 880 881 // Broadcast is being executed, its package can't be stopped. 882 try { 883 AppGlobals.getPackageManager().setPackageStoppedState( 884 r.curComponent.getPackageName(), false, UserHandle.getUserId(r.callingUid)); 885 } catch (RemoteException e) { 886 } catch (IllegalArgumentException e) { 887 Slog.w(TAG, "Failed trying to unstop package " 888 + r.curComponent.getPackageName() + ": " + e); 889 } 890 891 // Is this receiver's application already running? 892 ProcessRecord app = mService.getProcessRecordLocked(targetProcess, 893 info.activityInfo.applicationInfo.uid, false); 894 if (app != null && app.thread != null) { 895 try { 896 app.addPackage(info.activityInfo.packageName, 897 info.activityInfo.applicationInfo.versionCode, mService.mProcessStats); 898 processCurBroadcastLocked(r, app); 899 return; 900 } catch (RemoteException e) { 901 Slog.w(TAG, "Exception when sending broadcast to " 902 + r.curComponent, e); 903 } catch (RuntimeException e) { 904 Slog.wtf(TAG, "Failed sending broadcast to " 905 + r.curComponent + " with " + r.intent, e); 906 // If some unexpected exception happened, just skip 907 // this broadcast. At this point we are not in the call 908 // from a client, so throwing an exception out from here 909 // will crash the entire system instead of just whoever 910 // sent the broadcast. 911 logBroadcastReceiverDiscardLocked(r); 912 finishReceiverLocked(r, r.resultCode, r.resultData, 913 r.resultExtras, r.resultAbort, false); 914 scheduleBroadcastsLocked(); 915 // We need to reset the state if we failed to start the receiver. 916 r.state = BroadcastRecord.IDLE; 917 return; 918 } 919 920 // If a dead object exception was thrown -- fall through to 921 // restart the application. 922 } 923 924 // Not running -- get it started, to be executed when the app comes up. 925 if (DEBUG_BROADCAST) Slog.v(TAG, 926 "Need to start app [" 927 + mQueueName + "] " + targetProcess + " for broadcast " + r); 928 if ((r.curApp=mService.startProcessLocked(targetProcess, 929 info.activityInfo.applicationInfo, true, 930 r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND, 931 "broadcast", r.curComponent, 932 (r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0, false, false)) 933 == null) { 934 // Ah, this recipient is unavailable. Finish it if necessary, 935 // and mark the broadcast record as ready for the next. 936 Slog.w(TAG, "Unable to launch app " 937 + info.activityInfo.applicationInfo.packageName + "/" 938 + info.activityInfo.applicationInfo.uid + " for broadcast " 939 + r.intent + ": process is bad"); 940 logBroadcastReceiverDiscardLocked(r); 941 finishReceiverLocked(r, r.resultCode, r.resultData, 942 r.resultExtras, r.resultAbort, false); 943 scheduleBroadcastsLocked(); 944 r.state = BroadcastRecord.IDLE; 945 return; 946 } 947 948 mPendingBroadcast = r; 949 mPendingBroadcastRecvIndex = recIdx; 950 } 951 } 952 setBroadcastTimeoutLocked(long timeoutTime)953 final void setBroadcastTimeoutLocked(long timeoutTime) { 954 if (! mPendingBroadcastTimeoutMessage) { 955 Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG, this); 956 mHandler.sendMessageAtTime(msg, timeoutTime); 957 mPendingBroadcastTimeoutMessage = true; 958 } 959 } 960 cancelBroadcastTimeoutLocked()961 final void cancelBroadcastTimeoutLocked() { 962 if (mPendingBroadcastTimeoutMessage) { 963 mHandler.removeMessages(BROADCAST_TIMEOUT_MSG, this); 964 mPendingBroadcastTimeoutMessage = false; 965 } 966 } 967 broadcastTimeoutLocked(boolean fromMsg)968 final void broadcastTimeoutLocked(boolean fromMsg) { 969 if (fromMsg) { 970 mPendingBroadcastTimeoutMessage = false; 971 } 972 973 if (mOrderedBroadcasts.size() == 0) { 974 return; 975 } 976 977 long now = SystemClock.uptimeMillis(); 978 BroadcastRecord r = mOrderedBroadcasts.get(0); 979 if (fromMsg) { 980 if (mService.mDidDexOpt) { 981 // Delay timeouts until dexopt finishes. 982 mService.mDidDexOpt = false; 983 long timeoutTime = SystemClock.uptimeMillis() + mTimeoutPeriod; 984 setBroadcastTimeoutLocked(timeoutTime); 985 return; 986 } 987 if (!mService.mProcessesReady) { 988 // Only process broadcast timeouts if the system is ready. That way 989 // PRE_BOOT_COMPLETED broadcasts can't timeout as they are intended 990 // to do heavy lifting for system up. 991 return; 992 } 993 994 long timeoutTime = r.receiverTime + mTimeoutPeriod; 995 if (timeoutTime > now) { 996 // We can observe premature timeouts because we do not cancel and reset the 997 // broadcast timeout message after each receiver finishes. Instead, we set up 998 // an initial timeout then kick it down the road a little further as needed 999 // when it expires. 1000 if (DEBUG_BROADCAST) Slog.v(TAG, 1001 "Premature timeout [" 1002 + mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for " 1003 + timeoutTime); 1004 setBroadcastTimeoutLocked(timeoutTime); 1005 return; 1006 } 1007 } 1008 1009 BroadcastRecord br = mOrderedBroadcasts.get(0); 1010 if (br.state == BroadcastRecord.WAITING_SERVICES) { 1011 // In this case the broadcast had already finished, but we had decided to wait 1012 // for started services to finish as well before going on. So if we have actually 1013 // waited long enough time timeout the broadcast, let's give up on the whole thing 1014 // and just move on to the next. 1015 Slog.i(ActivityManagerService.TAG, "Waited long enough for: " + (br.curComponent != null 1016 ? br.curComponent.flattenToShortString() : "(null)")); 1017 br.curComponent = null; 1018 br.state = BroadcastRecord.IDLE; 1019 processNextBroadcast(false); 1020 return; 1021 } 1022 1023 Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r. receiver 1024 + ", started " + (now - r.receiverTime) + "ms ago"); 1025 r.receiverTime = now; 1026 r.anrCount++; 1027 1028 // Current receiver has passed its expiration date. 1029 if (r.nextReceiver <= 0) { 1030 Slog.w(TAG, "Timeout on receiver with nextReceiver <= 0"); 1031 return; 1032 } 1033 1034 ProcessRecord app = null; 1035 String anrMessage = null; 1036 1037 Object curReceiver = r.receivers.get(r.nextReceiver-1); 1038 Slog.w(TAG, "Receiver during timeout: " + curReceiver); 1039 logBroadcastReceiverDiscardLocked(r); 1040 if (curReceiver instanceof BroadcastFilter) { 1041 BroadcastFilter bf = (BroadcastFilter)curReceiver; 1042 if (bf.receiverList.pid != 0 1043 && bf.receiverList.pid != ActivityManagerService.MY_PID) { 1044 synchronized (mService.mPidsSelfLocked) { 1045 app = mService.mPidsSelfLocked.get( 1046 bf.receiverList.pid); 1047 } 1048 } 1049 } else { 1050 app = r.curApp; 1051 } 1052 1053 if (app != null) { 1054 anrMessage = "Broadcast of " + r.intent.toString(); 1055 } 1056 1057 if (mPendingBroadcast == r) { 1058 mPendingBroadcast = null; 1059 } 1060 1061 // Move on to the next receiver. 1062 finishReceiverLocked(r, r.resultCode, r.resultData, 1063 r.resultExtras, r.resultAbort, false); 1064 scheduleBroadcastsLocked(); 1065 1066 if (anrMessage != null) { 1067 // Post the ANR to the handler since we do not want to process ANRs while 1068 // potentially holding our lock. 1069 mHandler.post(new AppNotResponding(app, anrMessage)); 1070 } 1071 } 1072 addBroadcastToHistoryLocked(BroadcastRecord r)1073 private final void addBroadcastToHistoryLocked(BroadcastRecord r) { 1074 if (r.callingUid < 0) { 1075 // This was from a registerReceiver() call; ignore it. 1076 return; 1077 } 1078 System.arraycopy(mBroadcastHistory, 0, mBroadcastHistory, 1, 1079 MAX_BROADCAST_HISTORY-1); 1080 r.finishTime = SystemClock.uptimeMillis(); 1081 mBroadcastHistory[0] = r; 1082 System.arraycopy(mBroadcastSummaryHistory, 0, mBroadcastSummaryHistory, 1, 1083 MAX_BROADCAST_SUMMARY_HISTORY-1); 1084 mBroadcastSummaryHistory[0] = r.intent; 1085 } 1086 logBroadcastReceiverDiscardLocked(BroadcastRecord r)1087 final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) { 1088 if (r.nextReceiver > 0) { 1089 Object curReceiver = r.receivers.get(r.nextReceiver-1); 1090 if (curReceiver instanceof BroadcastFilter) { 1091 BroadcastFilter bf = (BroadcastFilter) curReceiver; 1092 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER, 1093 bf.owningUserId, System.identityHashCode(r), 1094 r.intent.getAction(), 1095 r.nextReceiver - 1, 1096 System.identityHashCode(bf)); 1097 } else { 1098 ResolveInfo ri = (ResolveInfo)curReceiver; 1099 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP, 1100 UserHandle.getUserId(ri.activityInfo.applicationInfo.uid), 1101 System.identityHashCode(r), r.intent.getAction(), 1102 r.nextReceiver - 1, ri.toString()); 1103 } 1104 } else { 1105 Slog.w(TAG, "Discarding broadcast before first receiver is invoked: " 1106 + r); 1107 EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP, 1108 -1, System.identityHashCode(r), 1109 r.intent.getAction(), 1110 r.nextReceiver, 1111 "NONE"); 1112 } 1113 } 1114 dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, int opti, boolean dumpAll, String dumpPackage, boolean needSep)1115 final boolean dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, 1116 int opti, boolean dumpAll, String dumpPackage, boolean needSep) { 1117 if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0 1118 || mPendingBroadcast != null) { 1119 boolean printed = false; 1120 for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { 1121 BroadcastRecord br = mParallelBroadcasts.get(i); 1122 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) { 1123 continue; 1124 } 1125 if (!printed) { 1126 if (needSep) { 1127 pw.println(); 1128 } 1129 needSep = true; 1130 printed = true; 1131 pw.println(" Active broadcasts [" + mQueueName + "]:"); 1132 } 1133 pw.println(" Active Broadcast " + mQueueName + " #" + i + ":"); 1134 br.dump(pw, " "); 1135 } 1136 printed = false; 1137 needSep = true; 1138 for (int i=mOrderedBroadcasts.size()-1; i>=0; i--) { 1139 BroadcastRecord br = mOrderedBroadcasts.get(i); 1140 if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) { 1141 continue; 1142 } 1143 if (!printed) { 1144 if (needSep) { 1145 pw.println(); 1146 } 1147 needSep = true; 1148 printed = true; 1149 pw.println(" Active ordered broadcasts [" + mQueueName + "]:"); 1150 } 1151 pw.println(" Active Ordered Broadcast " + mQueueName + " #" + i + ":"); 1152 mOrderedBroadcasts.get(i).dump(pw, " "); 1153 } 1154 if (dumpPackage == null || (mPendingBroadcast != null 1155 && dumpPackage.equals(mPendingBroadcast.callerPackage))) { 1156 if (needSep) { 1157 pw.println(); 1158 } 1159 pw.println(" Pending broadcast [" + mQueueName + "]:"); 1160 if (mPendingBroadcast != null) { 1161 mPendingBroadcast.dump(pw, " "); 1162 } else { 1163 pw.println(" (null)"); 1164 } 1165 needSep = true; 1166 } 1167 } 1168 1169 int i; 1170 boolean printed = false; 1171 for (i=0; i<MAX_BROADCAST_HISTORY; i++) { 1172 BroadcastRecord r = mBroadcastHistory[i]; 1173 if (r == null) { 1174 break; 1175 } 1176 if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) { 1177 continue; 1178 } 1179 if (!printed) { 1180 if (needSep) { 1181 pw.println(); 1182 } 1183 needSep = true; 1184 pw.println(" Historical broadcasts [" + mQueueName + "]:"); 1185 printed = true; 1186 } 1187 if (dumpAll) { 1188 pw.print(" Historical Broadcast " + mQueueName + " #"); 1189 pw.print(i); pw.println(":"); 1190 r.dump(pw, " "); 1191 } else { 1192 pw.print(" #"); pw.print(i); pw.print(": "); pw.println(r); 1193 pw.print(" "); 1194 pw.println(r.intent.toShortString(false, true, true, false)); 1195 if (r.targetComp != null && r.targetComp != r.intent.getComponent()) { 1196 pw.print(" targetComp: "); pw.println(r.targetComp.toShortString()); 1197 } 1198 Bundle bundle = r.intent.getExtras(); 1199 if (bundle != null) { 1200 pw.print(" extras: "); pw.println(bundle.toString()); 1201 } 1202 } 1203 } 1204 1205 if (dumpPackage == null) { 1206 if (dumpAll) { 1207 i = 0; 1208 printed = false; 1209 } 1210 for (; i<MAX_BROADCAST_SUMMARY_HISTORY; i++) { 1211 Intent intent = mBroadcastSummaryHistory[i]; 1212 if (intent == null) { 1213 break; 1214 } 1215 if (!printed) { 1216 if (needSep) { 1217 pw.println(); 1218 } 1219 needSep = true; 1220 pw.println(" Historical broadcasts summary [" + mQueueName + "]:"); 1221 printed = true; 1222 } 1223 if (!dumpAll && i >= 50) { 1224 pw.println(" ..."); 1225 break; 1226 } 1227 pw.print(" #"); pw.print(i); pw.print(": "); 1228 pw.println(intent.toShortString(false, true, true, false)); 1229 Bundle bundle = intent.getExtras(); 1230 if (bundle != null) { 1231 pw.print(" extras: "); pw.println(bundle.toString()); 1232 } 1233 } 1234 } 1235 1236 return needSep; 1237 } 1238 } 1239