* Each process now has its own broadcast queue represented by a * {@link BroadcastProcessQueue} instance. Each queue has a concept of being * "runnable at" a particular time in the future, which supports arbitrarily * pausing or delaying delivery on a per-process basis. *
* To keep things easy to reason about, there is a very strong * preference to have broadcast interactions flow through a consistent set of * methods in this specific order: *
* This is commonly used for callers that are blocked waiting for an * {@link #isIdleLocked} or {@link #isBeyondBarrierLocked} to be reached, * without requiring that they periodically poll for the state change. *
* Finally, the presence of any waiting latches will cause all
* future-runnable processes to be runnable immediately, to aid in reaching
* the desired state as quickly as possible.
*/
@GuardedBy("mService")
private final ArrayList
* We manually maintain this data structure since the lifecycle of
* {@link ProcessRecord} and {@link BroadcastProcessQueue} can be
* mismatched.
*/
@GuardedBy("mService")
private final SparseBooleanArray mUidForeground = new SparseBooleanArray();
private final BroadcastConstants mConstants;
private final BroadcastConstants mFgConstants;
private final BroadcastConstants mBgConstants;
/**
* Timestamp when last {@link #testAllProcessQueues} failure was observed;
* used for throttling log messages.
*/
private @UptimeMillisLong long mLastTestFailureTime;
/**
* The ANR timer service for broadcasts.
*/
@GuardedBy("mService")
private final BroadcastAnrTimer mAnrTimer;
private static final int MSG_UPDATE_RUNNING_LIST = 1;
private static final int MSG_DELIVERY_TIMEOUT = 2;
private static final int MSG_BG_ACTIVITY_START_TIMEOUT = 3;
private static final int MSG_CHECK_HEALTH = 4;
private static final int MSG_CHECK_PENDING_COLD_START_VALIDITY = 5;
private static final int MSG_PROCESS_FREEZABLE_CHANGED = 6;
private static final int MSG_UID_STATE_CHANGED = 7;
private void enqueueUpdateRunningList() {
mLocalHandler.removeMessages(MSG_UPDATE_RUNNING_LIST);
mLocalHandler.sendEmptyMessage(MSG_UPDATE_RUNNING_LIST);
}
private final Handler mLocalHandler;
private final Handler.Callback mLocalCallback = (msg) -> {
switch (msg.what) {
case MSG_UPDATE_RUNNING_LIST: {
updateRunningList();
return true;
}
case MSG_DELIVERY_TIMEOUT: {
deliveryTimeout((BroadcastProcessQueue) msg.obj);
return true;
}
case MSG_BG_ACTIVITY_START_TIMEOUT: {
synchronized (mService) {
final SomeArgs args = (SomeArgs) msg.obj;
final ProcessRecord app = (ProcessRecord) args.arg1;
final BroadcastRecord r = (BroadcastRecord) args.arg2;
args.recycle();
app.removeBackgroundStartPrivileges(r);
}
return true;
}
case MSG_CHECK_HEALTH: {
checkHealth();
return true;
}
case MSG_CHECK_PENDING_COLD_START_VALIDITY: {
synchronized (mService) {
/* Clear this as we have just received the broadcast. */
mCheckPendingColdStartQueued = false;
checkPendingColdStartValidityLocked();
}
return true;
}
case MSG_PROCESS_FREEZABLE_CHANGED: {
handleProcessFreezableChanged((ProcessRecord) msg.obj);
return true;
}
case MSG_UID_STATE_CHANGED: {
final int uid = (int) msg.obj;
final int procState = msg.arg1;
synchronized (mService) {
if (procState == ActivityManager.PROCESS_STATE_TOP) {
mUidForeground.put(uid, true);
} else {
mUidForeground.delete(uid);
}
refreshProcessQueuesLocked(uid);
}
return true;
}
}
return false;
};
/**
* Return the total number of active queues contained inside
* {@link #mRunning}.
*/
@GuardedBy("mService")
private int getRunningSize() {
int size = 0;
for (int i = 0; i < mRunning.length; i++) {
if (mRunning[i] != null) size++;
}
return size;
}
/**
* Return the number of active queues that are delivering "urgent" broadcasts
*/
@GuardedBy("mService")
private int getRunningUrgentCount() {
int count = 0;
for (int i = 0; i < mRunning.length; i++) {
if (mRunning[i] != null && mRunning[i].getActive().isUrgent()) {
count++;
}
}
return count;
}
/**
* Return the first index of the given value contained inside
* {@link #mRunning}, otherwise {@code -1}.
*/
@GuardedBy("mService")
private int getRunningIndexOf(@Nullable BroadcastProcessQueue test) {
for (int i = 0; i < mRunning.length; i++) {
if (mRunning[i] == test) return i;
}
return -1;
}
/**
* Consider updating the list of "runnable" queues, specifically with
* relation to the given queue.
*
* Typically called when {@link BroadcastProcessQueue#getRunnableAt()} might
* have changed, since that influences the order in which we'll promote a
* "runnable" queue to be "running."
*/
@GuardedBy("mService")
private void updateRunnableList(@NonNull BroadcastProcessQueue queue) {
if (getRunningIndexOf(queue) >= 0) {
// Already running; they'll be reinserted into the runnable list
// once they finish running, so no need to update them now
return;
}
// To place ourselves correctly in the runnable list, we may need to
// update internals that may have been invalidated; we wait until now at
// the last possible moment to avoid duplicated work
queue.updateDeferredStates(mBroadcastConsumerDeferApply, mBroadcastConsumerDeferClear);
queue.updateRunnableAt();
final boolean wantQueue = queue.isRunnable();
final boolean inQueue = (queue == mRunnableHead) || (queue.runnableAtPrev != null)
|| (queue.runnableAtNext != null);
if (wantQueue) {
if (inQueue) {
// We're in a good state, but our position within the linked
// list might need to move based on a runnableAt change
final boolean prevLower = (queue.runnableAtPrev != null)
? queue.runnableAtPrev.getRunnableAt() <= queue.getRunnableAt() : true;
final boolean nextHigher = (queue.runnableAtNext != null)
? queue.runnableAtNext.getRunnableAt() >= queue.getRunnableAt() : true;
if (!prevLower || !nextHigher) {
mRunnableHead = removeFromRunnableList(mRunnableHead, queue);
mRunnableHead = insertIntoRunnableList(mRunnableHead, queue);
}
} else {
mRunnableHead = insertIntoRunnableList(mRunnableHead, queue);
}
} else if (inQueue) {
mRunnableHead = removeFromRunnableList(mRunnableHead, queue);
}
// If app isn't running, and there's nothing in the queue, clean up
if (queue.isEmpty() && queue.isOutgoingEmpty() && !queue.isActive()
&& !queue.isProcessWarm()) {
removeProcessQueue(queue.processName, queue.uid);
}
}
private void updateRunningList() {
synchronized (mService) {
updateRunningListLocked();
}
}
/**
* Consider updating the list of "running" queues.
*
* This method can promote "runnable" queues to become "running", subject to
* a maximum of {@link BroadcastConstants#MAX_RUNNING_PROCESS_QUEUES} warm
* processes and only one pending cold-start.
*/
@GuardedBy("mService")
private void updateRunningListLocked() {
// Allocated size here implicitly includes the extra reservation for urgent
// dispatches beyond the MAX_RUNNING_QUEUES soft limit for normal
// parallelism. If we're already dispatching some urgent broadcasts,
// count that against the extra first - its role is to permit progress of
// urgent broadcast traffic when the normal reservation is fully occupied
// with less-urgent dispatches, not to generally expand parallelism.
final int usedExtra = Math.min(getRunningUrgentCount(),
mConstants.EXTRA_RUNNING_URGENT_PROCESS_QUEUES);
int avail = mRunning.length - getRunningSize() - usedExtra;
if (avail == 0) return;
final int cookie = traceBegin("updateRunningList");
final long now = SystemClock.uptimeMillis();
// If someone is waiting for a state, everything is runnable now
final boolean waitingFor = !mWaitingFor.isEmpty();
// We're doing an update now, so remove any future update requests;
// we'll repost below if needed
mLocalHandler.removeMessages(MSG_UPDATE_RUNNING_LIST);
boolean updateOomAdj = false;
BroadcastProcessQueue queue = mRunnableHead;
while (queue != null && avail > 0) {
BroadcastProcessQueue nextQueue = queue.runnableAtNext;
final long runnableAt = queue.getRunnableAt();
// When broadcasts are skipped or failed during list traversal, we
// might encounter a queue that is no longer runnable; skip it
if (!queue.isRunnable()) {
queue = nextQueue;
continue;
}
// If we've hit the soft limit for non-urgent dispatch parallelism,
// only consider delivering from queues whose ready broadcast is urgent
if (getRunningSize() >= mConstants.MAX_RUNNING_PROCESS_QUEUES) {
if (!queue.isPendingUrgent()) {
queue = nextQueue;
continue;
}
}
// If queues beyond this point aren't ready to run yet, schedule
// another pass when they'll be runnable
if (runnableAt > now && !waitingFor) {
mLocalHandler.sendEmptyMessageAtTime(MSG_UPDATE_RUNNING_LIST, runnableAt);
break;
}
// Clear the deferred state of broadcasts in this queue as we are just about to
// deliver broadcasts to this process.
queue.clearDeferredStates(mBroadcastConsumerDeferClear);
// We might not have heard about a newly running process yet, so
// consider refreshing if we think we're cold
updateWarmProcess(queue);
final boolean processWarm = queue.isProcessWarm();
if (processWarm) {
mService.unfreezeTemporarily(queue.app,
CachedAppOptimizer.UNFREEZE_REASON_START_RECEIVER);
// The process could be killed as part of unfreezing. So, check again if it
// is still warm.
if (!queue.isProcessWarm()) {
queue = nextQueue;
enqueueUpdateRunningList();
continue;
}
} else {
// We only offer to run one cold-start at a time to preserve
// system resources; below we either claim that single slot or
// skip to look for another warm process
if (mRunningColdStart == null) {
mRunningColdStart = queue;
mRunningColdStart.clearProcessStartInitiatedTimestampMillis();
} else if (isPendingColdStartValid()) {
// Move to considering next runnable queue
queue = nextQueue;
continue;
} else {
// Pending cold start is not valid, so clear it and move on.
clearInvalidPendingColdStart();
mRunningColdStart = queue;
mRunningColdStart.clearProcessStartInitiatedTimestampMillis();
}
}
if (DEBUG_BROADCAST) {
logv("Promoting " + queue + " from runnable to running; process is " + queue.app);
}
promoteToRunningLocked(queue);
boolean completed;
if (processWarm) {
updateOomAdj |= queue.runningOomAdjusted;
try {
completed = scheduleReceiverWarmLocked(queue);
} catch (BroadcastRetryException e) {
finishOrReEnqueueActiveBroadcast(queue);
completed = true;
}
} else {
completed = scheduleReceiverColdLocked(queue);
}
// If we are done with delivering the broadcasts to the process, we can demote it
// from the "running" list.
if (completed) {
demoteFromRunningLocked(queue);
}
// TODO: If delivering broadcasts to a process is finished, we don't have to hold
// a slot for it.
avail--;
// Move to considering next runnable queue
queue = nextQueue;
}
// TODO: We need to update oomAdj early as this currently doesn't guarantee that the
// procState is updated correctly when the app is handling a broadcast.
if (updateOomAdj) {
mService.updateOomAdjPendingTargetsLocked(OOM_ADJ_REASON_START_RECEIVER);
}
checkPendingColdStartValidityLocked();
checkAndRemoveWaitingFor();
traceEnd(cookie);
}
@GuardedBy("mService")
private boolean isPendingColdStartValid() {
if (mRunningColdStart.hasProcessStartInitiationTimedout()) {
return false;
} else if (mRunningColdStart.app.getPid() > 0) {
// If the process has already started, check if it wasn't killed.
return !mRunningColdStart.app.isKilled();
} else {
// Otherwise, check if the process start is still pending.
return mRunningColdStart.app.isPendingStart();
}
}
@GuardedBy("mService")
private void clearInvalidPendingColdStart() {
logw("Clearing invalid pending cold start: " + mRunningColdStart);
if (mRunningColdStart.wasActiveBroadcastReEnqueued()) {
finishReceiverActiveLocked(mRunningColdStart, BroadcastRecord.DELIVERY_FAILURE,
"invalid start with re-enqueued broadcast");
} else {
mRunningColdStart.reEnqueueActiveBroadcast();
}
final BroadcastProcessQueue queue = mRunningColdStart;
clearRunningColdStart();
demoteFromRunningLocked(queue);
enqueueUpdateRunningList();
}
@GuardedBy("mService")
private void checkPendingColdStartValidityLocked() {
// There are a few cases where a starting process gets killed but AMS doesn't report
// this event. So, once we start waiting for a pending cold start, periodically check
// if the pending start is still valid and if not, clear it so that the queue doesn't
// keep waiting for the process start forever.
// If there is no pending cold start, then nothing to do.
if (mRunningColdStart == null) {
return;
}
if (isPendingColdStartValid()) {
if (!mCheckPendingColdStartQueued) {
mLocalHandler.sendEmptyMessageDelayed(MSG_CHECK_PENDING_COLD_START_VALIDITY,
mConstants.PENDING_COLD_START_CHECK_INTERVAL_MILLIS);
mCheckPendingColdStartQueued = true;
}
} else {
clearInvalidPendingColdStart();
}
}
@GuardedBy("mService")
private void finishOrReEnqueueActiveBroadcast(@NonNull BroadcastProcessQueue queue) {
checkState(queue.isActive(), "isActive");
if (queue.wasActiveBroadcastReEnqueued()) {
// If the broadcast was already re-enqueued previously, finish it to avoid repeated
// delivery attempts
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_FAILURE,
"re-enqueued broadcast delivery failed");
} else {
final BroadcastRecord record = queue.getActive();
final int index = queue.getActiveIndex();
setDeliveryState(queue, queue.app, record, index, record.receivers.get(index),
BroadcastRecord.DELIVERY_PENDING, "reEnqueueActiveBroadcast");
queue.reEnqueueActiveBroadcast();
}
}
@GuardedBy("mService")
@Override
public boolean onApplicationAttachedLocked(@NonNull ProcessRecord app)
throws BroadcastRetryException {
if (DEBUG_BROADCAST) {
logv("Process " + app + " is attached");
}
// Process records can be recycled, so always start by looking up the
// relevant per-process queue
final BroadcastProcessQueue queue = getProcessQueue(app);
if (queue != null) {
setQueueProcess(queue, app);
// Outgoing broadcasts should be cleared when the process dies but there have been
// issues due to AMS not always informing the BroadcastQueue of process deaths.
// So, clear them when a new process starts as well.
queue.clearOutgoingBroadcasts();
}
boolean didSomething = false;
if ((mRunningColdStart != null) && (mRunningColdStart == queue)) {
// We've been waiting for this app to cold start, and it's ready
// now; dispatch its next broadcast and clear the slot
mRunningColdStart.clearProcessStartInitiatedTimestampMillis();
mRunningColdStart = null;
// Now that we're running warm, we can finally request that OOM
// adjust we've been waiting for
notifyStartedRunning(queue);
mService.updateOomAdjPendingTargetsLocked(OOM_ADJ_REASON_START_RECEIVER);
queue.traceProcessEnd();
queue.traceProcessRunningBegin();
try {
if (scheduleReceiverWarmLocked(queue)) {
demoteFromRunningLocked(queue);
}
} catch (BroadcastRetryException e) {
finishOrReEnqueueActiveBroadcast(queue);
demoteFromRunningLocked(queue);
throw e;
}
// We might be willing to kick off another cold start
enqueueUpdateRunningList();
didSomething = true;
}
return didSomething;
}
@GuardedBy("mService")
@Override
public void onApplicationTimeoutLocked(@NonNull ProcessRecord app) {
onApplicationCleanupLocked(app);
}
@GuardedBy("mService")
@Override
public void onApplicationProblemLocked(@NonNull ProcessRecord app) {
onApplicationCleanupLocked(app);
}
@GuardedBy("mService")
@Override
public void onApplicationCleanupLocked(@NonNull ProcessRecord app) {
if (DEBUG_BROADCAST) {
logv("Process " + app + " is cleaned up");
}
// This cleanup callback could be for an old process and not for the one we are waiting
// on, so explicitly check if this for the same ProcessRecord that a queue has.
final BroadcastProcessQueue queue = getProcessQueue(app);
if ((mRunningColdStart != null) && (mRunningColdStart == queue)
&& mRunningColdStart.app == app) {
clearRunningColdStart();
}
if (queue != null && queue.app == app) {
setQueueProcess(queue, null);
// If queue was running a broadcast, fail it
if (queue.isActive()) {
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_FAILURE,
"onApplicationCleanupLocked");
demoteFromRunningLocked(queue);
}
queue.clearOutgoingBroadcasts();
// Skip any pending registered receivers, since the old process
// would never be around to receive them
boolean didSomething = queue.forEachMatchingBroadcast((r, i) -> {
return (r.receivers.get(i) instanceof BroadcastFilter);
}, mBroadcastConsumerSkip, true);
if (didSomething || queue.isEmpty()) {
updateRunnableList(queue);
enqueueUpdateRunningList();
}
}
}
@GuardedBy("mService")
private void clearRunningColdStart() {
mRunningColdStart.traceProcessEnd();
// We've been waiting for this app to cold start, and it had
// trouble; clear the slot and fail delivery below
mRunningColdStart.clearProcessStartInitiatedTimestampMillis();
mRunningColdStart = null;
// We might be willing to kick off another cold start
enqueueUpdateRunningList();
}
@GuardedBy("mService")
@Override
public void onProcessFreezableChangedLocked(@NonNull ProcessRecord app) {
mLocalHandler.removeMessages(MSG_PROCESS_FREEZABLE_CHANGED, app);
mLocalHandler.obtainMessage(MSG_PROCESS_FREEZABLE_CHANGED, app).sendToTarget();
}
@GuardedBy("mService")
@Override
public int getPreferredSchedulingGroupLocked(@NonNull ProcessRecord app) {
final BroadcastProcessQueue queue = getProcessQueue(app);
if ((queue != null) && getRunningIndexOf(queue) >= 0) {
return queue.getPreferredSchedulingGroupLocked();
}
return ProcessList.SCHED_GROUP_UNDEFINED;
}
@GuardedBy("mService")
@Override
public void enqueueBroadcastLocked(@NonNull BroadcastRecord r) {
// TODO: Apply delivery group policies and FLAG_REPLACE_PENDING to collapse the
// outgoing broadcasts.
// TODO: Add traces/logs for the enqueueing outgoing broadcasts logic.
if (Flags.deferOutgoingBroadcasts() && isProcessFreezable(r.callerApp)) {
final BroadcastProcessQueue queue = getOrCreateProcessQueue(
r.callerApp.processName, r.callerApp.uid);
if (queue.getOutgoingBroadcastCount() >= mConstants.MAX_FROZEN_OUTGOING_BROADCASTS) {
r.callerApp.killLocked("Too many outgoing broadcasts in cached state",
ApplicationExitInfo.REASON_OTHER,
ApplicationExitInfo.SUBREASON_EXCESSIVE_OUTGOING_BROADCASTS_WHILE_CACHED,
true /* noisy */);
return;
}
queue.enqueueOutgoingBroadcast(r);
mHistory.onBroadcastFrozenLocked(r);
mService.getCachedAppOptimizer().freezeAppAsyncImmediateLSP(r.callerApp);
return;
}
if (DEBUG_BROADCAST || r.debugLog()) {
logv("Enqueuing " + r + " for " + r.receivers.size() + " receivers");
}
final int cookie = traceBegin("enqueueBroadcast");
r.applySingletonPolicy(mService);
applyDeliveryGroupPolicy(r);
r.enqueueTime = SystemClock.uptimeMillis();
r.enqueueRealTime = SystemClock.elapsedRealtime();
r.enqueueClockTime = System.currentTimeMillis();
mHistory.onBroadcastEnqueuedLocked(r);
ArraySet
* There is a very strong preference to consistently handle all
* results by calling through to {@link #finishReceiverLocked}, both in the
* case where a broadcast is handled by a remote app, and the case where the
* broadcast was finished locally without the remote app being involved.
*
* @return {@code true} if the broadcast delivery is finished and the process queue can
* be demoted from the running list. Otherwise {@code false}.
*/
@CheckResult
@GuardedBy("mService")
private boolean scheduleReceiverWarmLocked(@NonNull BroadcastProcessQueue queue)
throws BroadcastRetryException {
checkState(queue.isActive(), "isActive");
final int cookie = traceBegin("scheduleReceiverWarmLocked");
while (queue.isActive()) {
final BroadcastRecord r = queue.getActive();
final int index = queue.getActiveIndex();
if (r.terminalCount == 0) {
r.dispatchTime = SystemClock.uptimeMillis();
r.dispatchRealTime = SystemClock.elapsedRealtime();
r.dispatchClockTime = System.currentTimeMillis();
}
final String skipReason = shouldSkipReceiver(queue, r, index);
if (skipReason == null) {
final boolean isBlockingDispatch = dispatchReceivers(queue, r, index);
if (isBlockingDispatch) {
traceEnd(cookie);
return false;
}
} else {
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_SKIPPED, skipReason);
}
if (shouldRetire(queue)) {
break;
}
// We're on a roll; move onto the next broadcast for this process
queue.makeActiveNextPending();
}
traceEnd(cookie);
return true;
}
/**
* Consults {@link BroadcastSkipPolicy} and the receiver process state to decide whether or
* not the broadcast to a receiver can be skipped.
*/
@GuardedBy("mService")
private String shouldSkipReceiver(@NonNull BroadcastProcessQueue queue,
@NonNull BroadcastRecord r, int index) {
final int oldDeliveryState = getDeliveryState(r, index);
final ProcessRecord app = queue.app;
final Object receiver = r.receivers.get(index);
// If someone already finished this broadcast, finish immediately
if (isDeliveryStateTerminal(oldDeliveryState)) {
return "already terminal state";
}
// Consider additional cases where we'd want to finish immediately
if (app != null && app.isInFullBackup()) {
return "isInFullBackup";
}
final String skipReason = mSkipPolicy.shouldSkipMessage(r, receiver);
if (skipReason != null) {
return skipReason;
}
final Intent receiverIntent = r.getReceiverIntent(receiver);
if (receiverIntent == null) {
return "getReceiverIntent";
}
// Ignore registered receivers from a previous PID
if ((receiver instanceof BroadcastFilter)
&& ((BroadcastFilter) receiver).receiverList.pid != app.getPid()) {
return "BroadcastFilter for mismatched PID";
}
// The receiver was not handled in this method.
return null;
}
/**
* A receiver is about to be dispatched. Start ANR timers, if necessary.
*
* @return {@code true} if this a blocking delivery. That is, we are going to block on the
* finishReceiver() to be called before moving to the next broadcast. Otherwise,
* {@code false}.
*/
@GuardedBy("mService")
@CheckResult
private boolean dispatchReceivers(@NonNull BroadcastProcessQueue queue,
@NonNull BroadcastRecord r, int index) throws BroadcastRetryException {
final ProcessRecord app = queue.app;
final Object receiver = r.receivers.get(index);
// Skip ANR tracking early during boot, when requested, or when we
// immediately assume delivery success
final boolean assumeDelivered = r.isAssumedDelivered(index);
if (mService.mProcessesReady && !r.timeoutExempt && !assumeDelivered) {
queue.setTimeoutScheduled(true);
final int softTimeoutMillis = (int) (r.isForeground() ? mFgConstants.TIMEOUT
: mBgConstants.TIMEOUT);
startDeliveryTimeoutLocked(queue, softTimeoutMillis);
} else {
queue.setTimeoutScheduled(false);
}
if (r.mBackgroundStartPrivileges.allowsAny()
&& (r.realCallingUid != app.uid || !balCheckBroadcastWhenDispatched())) {
// allow the broadcast receiver potential privileges if it is not sent to itself
app.addOrUpdateBackgroundStartPrivileges(r, r.mBackgroundStartPrivileges);
final long timeout = r.isForeground() ? mFgConstants.ALLOW_BG_ACTIVITY_START_TIMEOUT
: mBgConstants.ALLOW_BG_ACTIVITY_START_TIMEOUT;
final SomeArgs args = SomeArgs.obtain();
args.arg1 = app;
args.arg2 = r;
mLocalHandler.sendMessageDelayed(
Message.obtain(mLocalHandler, MSG_BG_ACTIVITY_START_TIMEOUT, args), timeout);
}
if (r.options != null && r.options.getTemporaryAppAllowlistDuration() > 0) {
if (r.options.getTemporaryAppAllowlistType()
== PowerExemptionManager.TEMPORARY_ALLOW_LIST_TYPE_APP_FREEZING_DELAYED) {
// Only delay freezer, don't add to any temp allowlist
// TODO: Add a unit test
mService.getCachedAppOptimizer().unfreezeTemporarily(app,
CachedAppOptimizer.UNFREEZE_REASON_START_RECEIVER,
r.options.getTemporaryAppAllowlistDuration());
} else {
mService.tempAllowlistUidLocked(queue.uid,
r.options.getTemporaryAppAllowlistDuration(),
r.options.getTemporaryAppAllowlistReasonCode(), r.toShortString(),
r.options.getTemporaryAppAllowlistType(), r.callingUid);
}
}
if (DEBUG_BROADCAST || r.debugLog()) {
logv("Scheduling " + r + " to warm " + app);
}
setDeliveryState(queue, app, r, index, receiver, BroadcastRecord.DELIVERY_SCHEDULED,
"scheduleReceiverWarmLocked");
final Intent receiverIntent = r.getReceiverIntent(receiver);
final IApplicationThread thread = app.getOnewayThread();
if (thread != null) {
try {
if (r.shareIdentity) {
mService.mPackageManagerInt.grantImplicitAccess(r.userId, r.intent,
UserHandle.getAppId(app.uid), r.callingUid, true);
}
queue.lastProcessState = app.getCurProcState();
if (receiver instanceof BroadcastFilter) {
notifyScheduleRegisteredReceiver(app, r, (BroadcastFilter) receiver);
thread.scheduleRegisteredReceiver(
((BroadcastFilter) receiver).receiverList.receiver,
receiverIntent, r.resultCode, r.resultData, r.resultExtras,
r.ordered, r.initialSticky, assumeDelivered, r.userId,
app.getReportedProcState(),
r.shareIdentity ? r.callingUid : Process.INVALID_UID,
r.shareIdentity ? r.callerPackage : null);
// TODO: consider making registered receivers of unordered
// broadcasts report results to detect ANRs
if (assumeDelivered) {
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_DELIVERED,
"assuming delivered");
return false;
}
} else {
notifyScheduleReceiver(app, r, (ResolveInfo) receiver);
thread.scheduleReceiver(receiverIntent, ((ResolveInfo) receiver).activityInfo,
null, r.resultCode, r.resultData, r.resultExtras, r.ordered,
assumeDelivered, r.userId,
app.getReportedProcState(),
r.shareIdentity ? r.callingUid : Process.INVALID_UID,
r.shareIdentity ? r.callerPackage : null);
}
return true;
} catch (RemoteException e) {
final String msg = "Failed to schedule " + r + " to " + receiver
+ " via " + app + ": " + e;
logw(msg);
app.killLocked("Can't deliver broadcast", ApplicationExitInfo.REASON_OTHER,
ApplicationExitInfo.SUBREASON_UNDELIVERED_BROADCAST, true);
// If we were trying to deliver a manifest broadcast, throw the error as we need
// to try redelivering the broadcast to this receiver.
if (receiver instanceof ResolveInfo) {
cancelDeliveryTimeoutLocked(queue);
throw new BroadcastRetryException(e);
}
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_FAILURE,
"remote app");
return false;
}
} else {
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_FAILURE,
"missing IApplicationThread");
return false;
}
}
/**
* Schedule the final {@link BroadcastRecord#resultTo} delivery for an
* ordered broadcast; assumes the sender is still a warm process.
*/
@GuardedBy("mService")
private void scheduleResultTo(@NonNull BroadcastRecord r) {
if (r.resultTo == null) return;
final ProcessRecord app = r.resultToApp;
final IApplicationThread thread = (app != null) ? app.getOnewayThread() : null;
if (thread != null) {
mService.unfreezeTemporarily(
app, CachedAppOptimizer.UNFREEZE_REASON_FINISH_RECEIVER);
if (r.shareIdentity && app.uid != r.callingUid) {
mService.mPackageManagerInt.grantImplicitAccess(r.userId, r.intent,
UserHandle.getAppId(app.uid), r.callingUid, true);
}
try {
final boolean assumeDelivered = true;
thread.scheduleRegisteredReceiver(
r.resultTo, r.intent,
r.resultCode, r.resultData, r.resultExtras, false, r.initialSticky,
assumeDelivered, r.userId,
app.getReportedProcState(),
r.shareIdentity ? r.callingUid : Process.INVALID_UID,
r.shareIdentity ? r.callerPackage : null);
} catch (RemoteException e) {
final String msg = "Failed to schedule result of " + r + " via " + app + ": " + e;
logw(msg);
app.killLocked("Can't deliver broadcast", ApplicationExitInfo.REASON_OTHER,
ApplicationExitInfo.SUBREASON_UNDELIVERED_BROADCAST, true);
}
}
// Clear so both local and remote references can be GC'ed
r.resultTo = null;
}
// Required when Flags.anrTimerServiceEnabled is false. This function can be replaced with a
// single call to {@code mAnrTimer.start()} if and when the flag is fused on.
@GuardedBy("mService")
private void startDeliveryTimeoutLocked(@NonNull BroadcastProcessQueue queue,
int softTimeoutMillis) {
mAnrTimer.start(queue, softTimeoutMillis);
}
// Required when Flags.anrTimerServiceEnabled is false. This function can be replaced with a
// single call to {@code mAnrTimer.cancel()} if and when the flag is fused on.
@GuardedBy("mService")
private void cancelDeliveryTimeoutLocked(@NonNull BroadcastProcessQueue queue) {
mAnrTimer.cancel(queue);
}
private void deliveryTimeout(@NonNull BroadcastProcessQueue queue) {
final int cookie = traceBegin("deliveryTimeout");
synchronized (mService) {
deliveryTimeoutLocked(queue);
}
traceEnd(cookie);
}
@GuardedBy("mService")
private void deliveryTimeoutLocked(@NonNull BroadcastProcessQueue queue) {
finishReceiverActiveLocked(queue, BroadcastRecord.DELIVERY_TIMEOUT,
"deliveryTimeoutLocked");
demoteFromRunningLocked(queue);
}
private class BroadcastAnrTimer extends AnrTimer