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