/*
|
* Copyright (C) 2012 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
package com.android.server.am;
|
|
import static com.android.server.am.ActivityManagerDebugConfig.*;
|
|
import android.app.ActivityManager;
|
import android.app.AppGlobals;
|
import android.app.AppOpsManager;
|
import android.app.BroadcastOptions;
|
import android.app.PendingIntent;
|
import android.content.ComponentName;
|
import android.content.ContentResolver;
|
import android.content.IIntentReceiver;
|
import android.content.IIntentSender;
|
import android.content.Intent;
|
import android.content.IntentSender;
|
import android.content.pm.ActivityInfo;
|
import android.content.pm.IPackageManager;
|
import android.content.pm.PackageManager;
|
import android.content.pm.PermissionInfo;
|
import android.content.pm.ResolveInfo;
|
import android.os.Bundle;
|
import android.os.Handler;
|
import android.os.IBinder;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.os.Process;
|
import android.os.RemoteException;
|
import android.os.SystemClock;
|
import android.os.Trace;
|
import android.os.UserHandle;
|
import android.util.EventLog;
|
import android.util.Slog;
|
import android.util.SparseIntArray;
|
import android.util.StatsLog;
|
import android.util.TimeUtils;
|
import android.util.proto.ProtoOutputStream;
|
|
import java.io.FileDescriptor;
|
import java.io.PrintWriter;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.Set;
|
|
/**
|
* BROADCASTS
|
*
|
* We keep three broadcast queues and associated bookkeeping, one for those at
|
* foreground priority, and one for normal (background-priority) broadcasts, and one to
|
* offload special broadcasts that we know take a long time, such as BOOT_COMPLETED.
|
*/
|
public final class BroadcastQueue {
|
private static final String TAG = "BroadcastQueue";
|
private static final String TAG_MU = TAG + POSTFIX_MU;
|
private static final String TAG_BROADCAST = TAG + POSTFIX_BROADCAST;
|
|
static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50;
|
static final int MAX_BROADCAST_SUMMARY_HISTORY
|
= ActivityManager.isLowRamDeviceStatic() ? 25 : 300;
|
|
final ActivityManagerService mService;
|
|
/**
|
* Behavioral parameters such as timeouts and deferral policy, tracking Settings
|
* for runtime configurability
|
*/
|
final BroadcastConstants mConstants;
|
|
/**
|
* Recognizable moniker for this queue
|
*/
|
final String mQueueName;
|
|
/**
|
* If true, we can delay broadcasts while waiting services to finish in the previous
|
* receiver's process.
|
*/
|
final boolean mDelayBehindServices;
|
|
/**
|
* Lists of all active broadcasts that are to be executed immediately
|
* (without waiting for another broadcast to finish). Currently this only
|
* contains broadcasts to registered receivers, to avoid spinning up
|
* a bunch of processes to execute IntentReceiver components. Background-
|
* and foreground-priority broadcasts are queued separately.
|
*/
|
final ArrayList<BroadcastRecord> mParallelBroadcasts = new ArrayList<>();
|
|
/**
|
* Tracking of the ordered broadcast queue, including deferral policy and alarm
|
* prioritization.
|
*/
|
final BroadcastDispatcher mDispatcher;
|
|
/**
|
* Refcounting for completion callbacks of split/deferred broadcasts. The key
|
* is an opaque integer token assigned lazily when a broadcast is first split
|
* into multiple BroadcastRecord objects.
|
*/
|
final SparseIntArray mSplitRefcounts = new SparseIntArray();
|
private int mNextToken = 0;
|
|
/**
|
* Historical data of past broadcasts, for debugging. This is a ring buffer
|
* whose last element is at mHistoryNext.
|
*/
|
final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY];
|
int mHistoryNext = 0;
|
|
/**
|
* Summary of historical data of past broadcasts, for debugging. This is a
|
* ring buffer whose last element is at mSummaryHistoryNext.
|
*/
|
final Intent[] mBroadcastSummaryHistory = new Intent[MAX_BROADCAST_SUMMARY_HISTORY];
|
int mSummaryHistoryNext = 0;
|
|
/**
|
* Various milestone timestamps of entries in the mBroadcastSummaryHistory ring
|
* buffer, also tracked via the mSummaryHistoryNext index. These are all in wall
|
* clock time, not elapsed.
|
*/
|
final long[] mSummaryHistoryEnqueueTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
|
final long[] mSummaryHistoryDispatchTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
|
final long[] mSummaryHistoryFinishTime = new long[MAX_BROADCAST_SUMMARY_HISTORY];
|
|
/**
|
* Set when we current have a BROADCAST_INTENT_MSG in flight.
|
*/
|
boolean mBroadcastsScheduled = false;
|
|
/**
|
* True if we have a pending unexpired BROADCAST_TIMEOUT_MSG posted to our handler.
|
*/
|
boolean mPendingBroadcastTimeoutMessage;
|
|
/**
|
* Intent broadcasts that we have tried to start, but are
|
* waiting for the application's process to be created. We only
|
* need one per scheduling class (instead of a list) because we always
|
* process broadcasts one at a time, so no others can be started while
|
* waiting for this one.
|
*/
|
BroadcastRecord mPendingBroadcast = null;
|
|
/**
|
* The receiver index that is pending, to restart the broadcast if needed.
|
*/
|
int mPendingBroadcastRecvIndex;
|
|
static final int BROADCAST_INTENT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG;
|
static final int BROADCAST_TIMEOUT_MSG = ActivityManagerService.FIRST_BROADCAST_QUEUE_MSG + 1;
|
|
// log latency metrics for ordered broadcasts during BOOT_COMPLETED processing
|
boolean mLogLatencyMetrics = true;
|
|
final BroadcastHandler mHandler;
|
|
private final class BroadcastHandler extends Handler {
|
public BroadcastHandler(Looper looper) {
|
super(looper, null, true);
|
}
|
|
@Override
|
public void handleMessage(Message msg) {
|
switch (msg.what) {
|
case BROADCAST_INTENT_MSG: {
|
if (DEBUG_BROADCAST) Slog.v(
|
TAG_BROADCAST, "Received BROADCAST_INTENT_MSG ["
|
+ mQueueName + "]");
|
processNextBroadcast(true);
|
} break;
|
case BROADCAST_TIMEOUT_MSG: {
|
synchronized (mService) {
|
broadcastTimeoutLocked(true);
|
}
|
} break;
|
}
|
}
|
}
|
|
private final class AppNotResponding implements Runnable {
|
private final ProcessRecord mApp;
|
private final String mAnnotation;
|
|
public AppNotResponding(ProcessRecord app, String annotation) {
|
mApp = app;
|
mAnnotation = annotation;
|
}
|
|
@Override
|
public void run() {
|
mApp.appNotResponding(null, null, null, null, false, mAnnotation);
|
}
|
}
|
|
BroadcastQueue(ActivityManagerService service, Handler handler,
|
String name, BroadcastConstants constants, boolean allowDelayBehindServices) {
|
mService = service;
|
mHandler = new BroadcastHandler(handler.getLooper());
|
mQueueName = name;
|
mDelayBehindServices = allowDelayBehindServices;
|
|
mConstants = constants;
|
mDispatcher = new BroadcastDispatcher(this, mConstants, mHandler, mService);
|
}
|
|
void start(ContentResolver resolver) {
|
mDispatcher.start();
|
mConstants.startObserving(mHandler, resolver);
|
}
|
|
@Override
|
public String toString() {
|
return mQueueName;
|
}
|
|
public boolean isPendingBroadcastProcessLocked(int pid) {
|
return mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid;
|
}
|
|
public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
|
mParallelBroadcasts.add(r);
|
enqueueBroadcastHelper(r);
|
}
|
|
public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
|
mDispatcher.enqueueOrderedBroadcastLocked(r);
|
enqueueBroadcastHelper(r);
|
}
|
|
/**
|
* Don't call this method directly; call enqueueParallelBroadcastLocked or
|
* enqueueOrderedBroadcastLocked.
|
*/
|
private void enqueueBroadcastHelper(BroadcastRecord r) {
|
r.enqueueClockTime = System.currentTimeMillis();
|
|
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
|
Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
|
System.identityHashCode(r));
|
}
|
}
|
|
/**
|
* Find the same intent from queued parallel broadcast, replace with a new one and return
|
* the old one.
|
*/
|
public final BroadcastRecord replaceParallelBroadcastLocked(BroadcastRecord r) {
|
return replaceBroadcastLocked(mParallelBroadcasts, r, "PARALLEL");
|
}
|
|
/**
|
* Find the same intent from queued ordered broadcast, replace with a new one and return
|
* the old one.
|
*/
|
public final BroadcastRecord replaceOrderedBroadcastLocked(BroadcastRecord r) {
|
return mDispatcher.replaceBroadcastLocked(r, "ORDERED");
|
}
|
|
private BroadcastRecord replaceBroadcastLocked(ArrayList<BroadcastRecord> queue,
|
BroadcastRecord r, String typeForLogging) {
|
final Intent intent = r.intent;
|
for (int i = queue.size() - 1; i > 0; i--) {
|
final BroadcastRecord old = queue.get(i);
|
if (old.userId == r.userId && intent.filterEquals(old.intent)) {
|
if (DEBUG_BROADCAST) {
|
Slog.v(TAG_BROADCAST, "***** DROPPING "
|
+ typeForLogging + " [" + mQueueName + "]: " + intent);
|
}
|
queue.set(i, r);
|
return old;
|
}
|
}
|
return null;
|
}
|
|
private final void processCurBroadcastLocked(BroadcastRecord r,
|
ProcessRecord app, boolean skipOomAdj) throws RemoteException {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Process cur broadcast " + r + " for app " + app);
|
if (app.thread == null) {
|
throw new RemoteException();
|
}
|
if (app.inFullBackup) {
|
skipReceiverLocked(r);
|
return;
|
}
|
|
r.receiver = app.thread.asBinder();
|
r.curApp = app;
|
app.curReceivers.add(r);
|
app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_RECEIVER);
|
mService.mProcessList.updateLruProcessLocked(app, false, null);
|
if (!skipOomAdj) {
|
mService.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
|
}
|
|
// Tell the application to launch this receiver.
|
r.intent.setComponent(r.curComponent);
|
|
boolean started = false;
|
try {
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
|
"Delivering to component " + r.curComponent
|
+ ": " + r);
|
mService.notifyPackageUse(r.intent.getComponent().getPackageName(),
|
PackageManager.NOTIFY_PACKAGE_USE_BROADCAST_RECEIVER);
|
app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver,
|
mService.compatibilityInfoForPackage(r.curReceiver.applicationInfo),
|
r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId,
|
app.getReportedProcState());
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Process cur broadcast " + r + " DELIVERED for app " + app);
|
started = true;
|
} finally {
|
if (!started) {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Process cur broadcast " + r + ": NOT STARTED!");
|
r.receiver = null;
|
r.curApp = null;
|
app.curReceivers.remove(r);
|
}
|
}
|
}
|
|
public boolean sendPendingBroadcastsLocked(ProcessRecord app) {
|
boolean didSomething = false;
|
final BroadcastRecord br = mPendingBroadcast;
|
if (br != null && br.curApp.pid > 0 && br.curApp.pid == app.pid) {
|
if (br.curApp != app) {
|
Slog.e(TAG, "App mismatch when sending pending broadcast to "
|
+ app.processName + ", intended target is " + br.curApp.processName);
|
return false;
|
}
|
try {
|
mPendingBroadcast = null;
|
processCurBroadcastLocked(br, app, false);
|
didSomething = true;
|
} catch (Exception e) {
|
Slog.w(TAG, "Exception in new application when starting receiver "
|
+ br.curComponent.flattenToShortString(), e);
|
logBroadcastReceiverDiscardLocked(br);
|
finishReceiverLocked(br, br.resultCode, br.resultData,
|
br.resultExtras, br.resultAbort, false);
|
scheduleBroadcastsLocked();
|
// We need to reset the state if we failed to start the receiver.
|
br.state = BroadcastRecord.IDLE;
|
throw new RuntimeException(e.getMessage());
|
}
|
}
|
return didSomething;
|
}
|
|
public void skipPendingBroadcastLocked(int pid) {
|
final BroadcastRecord br = mPendingBroadcast;
|
if (br != null && br.curApp.pid == pid) {
|
br.state = BroadcastRecord.IDLE;
|
br.nextReceiver = mPendingBroadcastRecvIndex;
|
mPendingBroadcast = null;
|
scheduleBroadcastsLocked();
|
}
|
}
|
|
// Skip the current receiver, if any, that is in flight to the given process
|
public void skipCurrentReceiverLocked(ProcessRecord app) {
|
BroadcastRecord r = null;
|
final BroadcastRecord curActive = mDispatcher.getActiveBroadcastLocked();
|
if (curActive != null && curActive.curApp == app) {
|
// confirmed: the current active broadcast is to the given app
|
r = curActive;
|
}
|
|
// If the current active broadcast isn't this BUT we're waiting for
|
// mPendingBroadcast to spin up the target app, that's what we use.
|
if (r == null && mPendingBroadcast != null && mPendingBroadcast.curApp == app) {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"[" + mQueueName + "] skip & discard pending app " + r);
|
r = mPendingBroadcast;
|
}
|
|
if (r != null) {
|
skipReceiverLocked(r);
|
}
|
}
|
|
private void skipReceiverLocked(BroadcastRecord r) {
|
logBroadcastReceiverDiscardLocked(r);
|
finishReceiverLocked(r, r.resultCode, r.resultData,
|
r.resultExtras, r.resultAbort, false);
|
scheduleBroadcastsLocked();
|
}
|
|
public void scheduleBroadcastsLocked() {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Schedule broadcasts ["
|
+ mQueueName + "]: current="
|
+ mBroadcastsScheduled);
|
|
if (mBroadcastsScheduled) {
|
return;
|
}
|
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
|
mBroadcastsScheduled = true;
|
}
|
|
public BroadcastRecord getMatchingOrderedReceiver(IBinder receiver) {
|
BroadcastRecord br = mDispatcher.getActiveBroadcastLocked();
|
if (br != null && br.receiver == receiver) {
|
return br;
|
}
|
return null;
|
}
|
|
// > 0 only, no worry about "eventual" recycling
|
private int nextSplitTokenLocked() {
|
int next = mNextToken + 1;
|
if (next <= 0) {
|
next = 1;
|
}
|
mNextToken = next;
|
return next;
|
}
|
|
private void postActivityStartTokenRemoval(ProcessRecord app, BroadcastRecord r) {
|
// the receiver had run for less than allowed bg activity start timeout,
|
// so allow the process to still start activities from bg for some more time
|
String msgToken = (app.toShortString() + r.toString()).intern();
|
// first, if there exists a past scheduled request to remove this token, drop
|
// that request - we don't want the token to be swept from under our feet...
|
mHandler.removeCallbacksAndMessages(msgToken);
|
// ...then schedule the removal of the token after the extended timeout
|
mHandler.postAtTime(() -> {
|
app.removeAllowBackgroundActivityStartsToken(r);
|
}, msgToken, (r.receiverTime + mConstants.ALLOW_BG_ACTIVITY_START_TIMEOUT));
|
}
|
|
public boolean finishReceiverLocked(BroadcastRecord r, int resultCode,
|
String resultData, Bundle resultExtras, boolean resultAbort, boolean waitForServices) {
|
final int state = r.state;
|
final ActivityInfo receiver = r.curReceiver;
|
final long finishTime = SystemClock.uptimeMillis();
|
final long elapsed = finishTime - r.receiverTime;
|
r.state = BroadcastRecord.IDLE;
|
if (state == BroadcastRecord.IDLE) {
|
Slog.w(TAG_BROADCAST, "finishReceiver [" + mQueueName + "] called but state is IDLE");
|
}
|
if (r.allowBackgroundActivityStarts && r.curApp != null) {
|
if (elapsed > mConstants.ALLOW_BG_ACTIVITY_START_TIMEOUT) {
|
// if the receiver has run for more than allowed bg activity start timeout,
|
// just remove the token for this process now and we're done
|
r.curApp.removeAllowBackgroundActivityStartsToken(r);
|
} else {
|
// It gets more time; post the removal to happen at the appropriate moment
|
postActivityStartTokenRemoval(r.curApp, r);
|
}
|
}
|
// If we're abandoning this broadcast before any receivers were actually spun up,
|
// nextReceiver is zero; in which case time-to-process bookkeeping doesn't apply.
|
if (r.nextReceiver > 0) {
|
r.duration[r.nextReceiver - 1] = elapsed;
|
}
|
|
// if this receiver was slow, impose deferral policy on the app. This will kick in
|
// when processNextBroadcastLocked() next finds this uid as a receiver identity.
|
if (!r.timeoutExempt) {
|
if (mConstants.SLOW_TIME > 0 && elapsed > mConstants.SLOW_TIME) {
|
// Core system packages are exempt from deferral policy
|
if (!UserHandle.isCore(r.curApp.uid)) {
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Broadcast receiver " + (r.nextReceiver - 1)
|
+ " was slow: " + receiver + " br=" + r);
|
}
|
if (r.curApp != null) {
|
mDispatcher.startDeferring(r.curApp.uid);
|
} else {
|
Slog.d(TAG_BROADCAST, "finish receiver curApp is null? " + r);
|
}
|
} else {
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Core uid " + r.curApp.uid
|
+ " receiver was slow but not deferring: " + receiver + " br=" + r);
|
}
|
}
|
}
|
} else {
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Finished broadcast " + r.intent.getAction()
|
+ " is exempt from deferral policy");
|
}
|
}
|
|
r.receiver = null;
|
r.intent.setComponent(null);
|
if (r.curApp != null && r.curApp.curReceivers.contains(r)) {
|
r.curApp.curReceivers.remove(r);
|
}
|
if (r.curFilter != null) {
|
r.curFilter.receiverList.curBroadcast = null;
|
}
|
r.curFilter = null;
|
r.curReceiver = null;
|
r.curApp = null;
|
mPendingBroadcast = null;
|
|
r.resultCode = resultCode;
|
r.resultData = resultData;
|
r.resultExtras = resultExtras;
|
if (resultAbort && (r.intent.getFlags()&Intent.FLAG_RECEIVER_NO_ABORT) == 0) {
|
r.resultAbort = resultAbort;
|
} else {
|
r.resultAbort = false;
|
}
|
|
// If we want to wait behind services *AND* we're finishing the head/
|
// active broadcast on its queue
|
if (waitForServices && r.curComponent != null && r.queue.mDelayBehindServices
|
&& r.queue.mDispatcher.getActiveBroadcastLocked() == r) {
|
ActivityInfo nextReceiver;
|
if (r.nextReceiver < r.receivers.size()) {
|
Object obj = r.receivers.get(r.nextReceiver);
|
nextReceiver = (obj instanceof ActivityInfo) ? (ActivityInfo)obj : null;
|
} else {
|
nextReceiver = null;
|
}
|
// Don't do this if the next receive is in the same process as the current one.
|
if (receiver == null || nextReceiver == null
|
|| receiver.applicationInfo.uid != nextReceiver.applicationInfo.uid
|
|| !receiver.processName.equals(nextReceiver.processName)) {
|
// In this case, we are ready to process the next receiver for the current broadcast,
|
//Â but are on a queue that would like to wait for services to finish before moving
|
// on. If there are background services currently starting, then we will go into a
|
// special state where we hold off on continuing this broadcast until they are done.
|
if (mService.mServices.hasBackgroundServicesLocked(r.userId)) {
|
Slog.i(TAG, "Delay finish: " + r.curComponent.flattenToShortString());
|
r.state = BroadcastRecord.WAITING_SERVICES;
|
return false;
|
}
|
}
|
}
|
|
r.curComponent = null;
|
|
// We will process the next receiver right now if this is finishing
|
// an app receiver (which is always asynchronous) or after we have
|
// come back from calling a receiver.
|
return state == BroadcastRecord.APP_RECEIVE
|
|| state == BroadcastRecord.CALL_DONE_RECEIVE;
|
}
|
|
public void backgroundServicesFinishedLocked(int userId) {
|
BroadcastRecord br = mDispatcher.getActiveBroadcastLocked();
|
if (br != null) {
|
if (br.userId == userId && br.state == BroadcastRecord.WAITING_SERVICES) {
|
Slog.i(TAG, "Resuming delayed broadcast");
|
br.curComponent = null;
|
br.state = BroadcastRecord.IDLE;
|
processNextBroadcast(false);
|
}
|
}
|
}
|
|
void performReceiveLocked(ProcessRecord app, IIntentReceiver receiver,
|
Intent intent, int resultCode, String data, Bundle extras,
|
boolean ordered, boolean sticky, int sendingUser)
|
throws RemoteException {
|
// Send the intent to the receiver asynchronously using one-way binder calls.
|
if (app != null) {
|
if (app.thread != null) {
|
// If we have an app thread, do the call through that so it is
|
// correctly ordered with other one-way calls.
|
try {
|
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
|
data, extras, ordered, sticky, sendingUser, app.getReportedProcState());
|
// TODO: Uncomment this when (b/28322359) is fixed and we aren't getting
|
// DeadObjectException when the process isn't actually dead.
|
//} catch (DeadObjectException ex) {
|
// Failed to call into the process. It's dying so just let it die and move on.
|
// throw ex;
|
} catch (RemoteException ex) {
|
// Failed to call into the process. It's either dying or wedged. Kill it gently.
|
synchronized (mService) {
|
Slog.w(TAG, "Can't deliver broadcast to " + app.processName
|
+ " (pid " + app.pid + "). Crashing it.");
|
app.scheduleCrash("can't deliver broadcast");
|
}
|
throw ex;
|
}
|
} else {
|
// Application has died. Receiver doesn't exist.
|
throw new RemoteException("app.thread must not be null");
|
}
|
} else {
|
receiver.performReceive(intent, resultCode, data, extras, ordered,
|
sticky, sendingUser);
|
}
|
}
|
|
private void deliverToRegisteredReceiverLocked(BroadcastRecord r,
|
BroadcastFilter filter, boolean ordered, int index) {
|
boolean skip = false;
|
if (!mService.validateAssociationAllowedLocked(r.callerPackage, r.callingUid,
|
filter.packageName, filter.owningUid)) {
|
Slog.w(TAG, "Association not allowed: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ") to " + filter.packageName + " through "
|
+ filter);
|
skip = true;
|
}
|
if (!skip && !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
|
r.callingPid, r.resolvedType, filter.receiverList.uid)) {
|
Slog.w(TAG, "Firewall blocked: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ") to " + filter.packageName + " through "
|
+ filter);
|
skip = true;
|
}
|
if (filter.requiredPermission != null) {
|
int perm = mService.checkComponentPermission(filter.requiredPermission,
|
r.callingPid, r.callingUid, -1, true);
|
if (perm != PackageManager.PERMISSION_GRANTED) {
|
Slog.w(TAG, "Permission Denial: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid="
|
+ r.callingPid + ", uid=" + r.callingUid + ")"
|
+ " requires " + filter.requiredPermission
|
+ " due to registered receiver " + filter);
|
skip = true;
|
} else {
|
final int opCode = AppOpsManager.permissionToOpCode(filter.requiredPermission);
|
if (opCode != AppOpsManager.OP_NONE
|
&& mService.mAppOpsService.noteOperation(opCode, r.callingUid,
|
r.callerPackage) != AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid="
|
+ r.callingPid + ", uid=" + r.callingUid + ")"
|
+ " requires appop " + AppOpsManager.permissionToOp(
|
filter.requiredPermission)
|
+ " due to registered receiver " + filter);
|
skip = true;
|
}
|
}
|
}
|
if (!skip && r.requiredPermissions != null && r.requiredPermissions.length > 0) {
|
for (int i = 0; i < r.requiredPermissions.length; i++) {
|
String requiredPermission = r.requiredPermissions[i];
|
int perm = mService.checkComponentPermission(requiredPermission,
|
filter.receiverList.pid, filter.receiverList.uid, -1, true);
|
if (perm != PackageManager.PERMISSION_GRANTED) {
|
Slog.w(TAG, "Permission Denial: receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " requires " + requiredPermission
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
break;
|
}
|
int appOp = AppOpsManager.permissionToOpCode(requiredPermission);
|
if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp
|
&& mService.mAppOpsService.noteOperation(appOp,
|
filter.receiverList.uid, filter.packageName)
|
!= AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " requires appop " + AppOpsManager.permissionToOp(
|
requiredPermission)
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
break;
|
}
|
}
|
}
|
if (!skip && (r.requiredPermissions == null || r.requiredPermissions.length == 0)) {
|
int perm = mService.checkComponentPermission(null,
|
filter.receiverList.pid, filter.receiverList.uid, -1, true);
|
if (perm != PackageManager.PERMISSION_GRANTED) {
|
Slog.w(TAG, "Permission Denial: security check failed when receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
}
|
}
|
if (!skip && r.appOp != AppOpsManager.OP_NONE
|
&& mService.mAppOpsService.noteOperation(r.appOp,
|
filter.receiverList.uid, filter.packageName)
|
!= AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " requires appop " + AppOpsManager.opToName(r.appOp)
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
}
|
|
if (!skip && (filter.receiverList.app == null || filter.receiverList.app.killed
|
|| filter.receiverList.app.isCrashing())) {
|
Slog.w(TAG, "Skipping deliver [" + mQueueName + "] " + r
|
+ " to " + filter.receiverList + ": process gone or crashing");
|
skip = true;
|
}
|
|
// Ensure that broadcasts are only sent to other Instant Apps if they are marked as
|
// visible to Instant Apps.
|
final boolean visibleToInstantApps =
|
(r.intent.getFlags() & Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS) != 0;
|
|
if (!skip && !visibleToInstantApps && filter.instantApp
|
&& filter.receiverList.uid != r.callingUid) {
|
Slog.w(TAG, "Instant App Denial: receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")"
|
+ " not specifying FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS");
|
skip = true;
|
}
|
|
if (!skip && !filter.visibleToInstantApp && r.callerInstantApp
|
&& filter.receiverList.uid != r.callingUid) {
|
Slog.w(TAG, "Instant App Denial: receiving "
|
+ r.intent.toString()
|
+ " to " + filter.receiverList.app
|
+ " (pid=" + filter.receiverList.pid
|
+ ", uid=" + filter.receiverList.uid + ")"
|
+ " requires receiver be visible to instant apps"
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
}
|
|
if (skip) {
|
r.delivery[index] = BroadcastRecord.DELIVERY_SKIPPED;
|
return;
|
}
|
|
// If permissions need a review before any of the app components can run, we drop
|
// the broadcast and if the calling app is in the foreground and the broadcast is
|
// explicit we launch the review UI passing it a pending intent to send the skipped
|
// broadcast.
|
if (!requestStartTargetPermissionsReviewIfNeededLocked(r, filter.packageName,
|
filter.owningUserId)) {
|
r.delivery[index] = BroadcastRecord.DELIVERY_SKIPPED;
|
return;
|
}
|
|
r.delivery[index] = BroadcastRecord.DELIVERY_DELIVERED;
|
|
// If this is not being sent as an ordered broadcast, then we
|
// don't want to touch the fields that keep track of the current
|
// state of ordered broadcasts.
|
if (ordered) {
|
r.receiver = filter.receiverList.receiver.asBinder();
|
r.curFilter = filter;
|
filter.receiverList.curBroadcast = r;
|
r.state = BroadcastRecord.CALL_IN_RECEIVE;
|
if (filter.receiverList.app != null) {
|
// Bump hosting application to no longer be in background
|
// scheduling class. Note that we can't do that if there
|
// isn't an app... but we can only be in that case for
|
// things that directly call the IActivityManager API, which
|
// are already core system stuff so don't matter for this.
|
r.curApp = filter.receiverList.app;
|
filter.receiverList.app.curReceivers.add(r);
|
mService.updateOomAdjLocked(r.curApp, true,
|
OomAdjuster.OOM_ADJ_REASON_START_RECEIVER);
|
}
|
}
|
try {
|
if (DEBUG_BROADCAST_LIGHT) Slog.i(TAG_BROADCAST,
|
"Delivering to " + filter + " : " + r);
|
if (filter.receiverList.app != null && filter.receiverList.app.inFullBackup) {
|
// Skip delivery if full backup in progress
|
// If it's an ordered broadcast, we need to continue to the next receiver.
|
if (ordered) {
|
skipReceiverLocked(r);
|
}
|
} else {
|
r.receiverTime = SystemClock.uptimeMillis();
|
maybeAddAllowBackgroundActivityStartsToken(filter.receiverList.app, r);
|
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
|
new Intent(r.intent), r.resultCode, r.resultData,
|
r.resultExtras, r.ordered, r.initialSticky, r.userId);
|
// parallel broadcasts are fire-and-forget, not bookended by a call to
|
// finishReceiverLocked(), so we manage their activity-start token here
|
if (r.allowBackgroundActivityStarts && !r.ordered) {
|
postActivityStartTokenRemoval(filter.receiverList.app, r);
|
}
|
}
|
if (ordered) {
|
r.state = BroadcastRecord.CALL_DONE_RECEIVE;
|
}
|
} catch (RemoteException e) {
|
Slog.w(TAG, "Failure sending broadcast " + r.intent, e);
|
// Clean up ProcessRecord state related to this broadcast attempt
|
if (filter.receiverList.app != null) {
|
filter.receiverList.app.removeAllowBackgroundActivityStartsToken(r);
|
if (ordered) {
|
filter.receiverList.app.curReceivers.remove(r);
|
}
|
}
|
// And BroadcastRecord state related to ordered delivery, if appropriate
|
if (ordered) {
|
r.receiver = null;
|
r.curFilter = null;
|
filter.receiverList.curBroadcast = null;
|
}
|
}
|
}
|
|
private boolean requestStartTargetPermissionsReviewIfNeededLocked(
|
BroadcastRecord receiverRecord, String receivingPackageName,
|
final int receivingUserId) {
|
if (!mService.getPackageManagerInternalLocked().isPermissionsReviewRequired(
|
receivingPackageName, receivingUserId)) {
|
return true;
|
}
|
|
final boolean callerForeground = receiverRecord.callerApp != null
|
? receiverRecord.callerApp.setSchedGroup != ProcessList.SCHED_GROUP_BACKGROUND
|
: true;
|
|
// Show a permission review UI only for explicit broadcast from a foreground app
|
if (callerForeground && receiverRecord.intent.getComponent() != null) {
|
IIntentSender target = mService.mPendingIntentController.getIntentSender(
|
ActivityManager.INTENT_SENDER_BROADCAST, receiverRecord.callerPackage,
|
receiverRecord.callingUid, receiverRecord.userId, null, null, 0,
|
new Intent[]{receiverRecord.intent},
|
new String[]{receiverRecord.intent.resolveType(mService.mContext
|
.getContentResolver())},
|
PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT
|
| PendingIntent.FLAG_IMMUTABLE, null);
|
|
final Intent intent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
|
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK
|
| Intent.FLAG_ACTIVITY_MULTIPLE_TASK
|
| Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
|
intent.putExtra(Intent.EXTRA_PACKAGE_NAME, receivingPackageName);
|
intent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target));
|
|
if (DEBUG_PERMISSIONS_REVIEW) {
|
Slog.i(TAG, "u" + receivingUserId + " Launching permission review for package "
|
+ receivingPackageName);
|
}
|
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mService.mContext.startActivityAsUser(intent, new UserHandle(receivingUserId));
|
}
|
});
|
} else {
|
Slog.w(TAG, "u" + receivingUserId + " Receiving a broadcast in package"
|
+ receivingPackageName + " requires a permissions review");
|
}
|
|
return false;
|
}
|
|
final void scheduleTempWhitelistLocked(int uid, long duration, BroadcastRecord r) {
|
if (duration > Integer.MAX_VALUE) {
|
duration = Integer.MAX_VALUE;
|
}
|
// XXX ideally we should pause the broadcast until everything behind this is done,
|
// or else we will likely start dispatching the broadcast before we have opened
|
// access to the app (there is a lot of asynchronicity behind this). It is probably
|
// not that big a deal, however, because the main purpose here is to allow apps
|
// to hold wake locks, and they will be able to acquire their wake lock immediately
|
// it just won't be enabled until we get through this work.
|
StringBuilder b = new StringBuilder();
|
b.append("broadcast:");
|
UserHandle.formatUid(b, r.callingUid);
|
b.append(":");
|
if (r.intent.getAction() != null) {
|
b.append(r.intent.getAction());
|
} else if (r.intent.getComponent() != null) {
|
r.intent.getComponent().appendShortString(b);
|
} else if (r.intent.getData() != null) {
|
b.append(r.intent.getData());
|
}
|
mService.tempWhitelistUidLocked(uid, duration, b.toString());
|
}
|
|
/**
|
* Return true if all given permissions are signature-only perms.
|
*/
|
final boolean isSignaturePerm(String[] perms) {
|
if (perms == null) {
|
return false;
|
}
|
IPackageManager pm = AppGlobals.getPackageManager();
|
for (int i = perms.length-1; i >= 0; i--) {
|
try {
|
PermissionInfo pi = pm.getPermissionInfo(perms[i], "android", 0);
|
if (pi == null) {
|
// a required permission that no package has actually
|
// defined cannot be signature-required.
|
return false;
|
}
|
if ((pi.protectionLevel & (PermissionInfo.PROTECTION_MASK_BASE
|
| PermissionInfo.PROTECTION_FLAG_PRIVILEGED))
|
!= PermissionInfo.PROTECTION_SIGNATURE) {
|
// If this a signature permission and NOT allowed for privileged apps, it
|
// is okay... otherwise, nope!
|
return false;
|
}
|
} catch (RemoteException e) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
final void processNextBroadcast(boolean fromMsg) {
|
synchronized (mService) {
|
processNextBroadcastLocked(fromMsg, false);
|
}
|
}
|
|
final void processNextBroadcastLocked(boolean fromMsg, boolean skipOomAdj) {
|
BroadcastRecord r;
|
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "processNextBroadcast ["
|
+ mQueueName + "]: "
|
+ mParallelBroadcasts.size() + " parallel broadcasts; "
|
+ mDispatcher.describeStateLocked());
|
|
mService.updateCpuStats();
|
|
if (fromMsg) {
|
mBroadcastsScheduled = false;
|
}
|
|
// First, deliver any non-serialized broadcasts right away.
|
while (mParallelBroadcasts.size() > 0) {
|
r = mParallelBroadcasts.remove(0);
|
r.dispatchTime = SystemClock.uptimeMillis();
|
r.dispatchClockTime = System.currentTimeMillis();
|
|
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
|
Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
|
System.identityHashCode(r));
|
Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
|
System.identityHashCode(r));
|
}
|
|
final int N = r.receivers.size();
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing parallel broadcast ["
|
+ mQueueName + "] " + r);
|
for (int i=0; i<N; i++) {
|
Object target = r.receivers.get(i);
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Delivering non-ordered on [" + mQueueName + "] to registered "
|
+ target + ": " + r);
|
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false, i);
|
}
|
addBroadcastToHistoryLocked(r);
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Done with parallel broadcast ["
|
+ mQueueName + "] " + r);
|
}
|
|
// Now take care of the next serialized one...
|
|
// If we are waiting for a process to come up to handle the next
|
// broadcast, then do nothing at this point. Just in case, we
|
// check that the process we're waiting for still exists.
|
if (mPendingBroadcast != null) {
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
|
"processNextBroadcast [" + mQueueName + "]: waiting for "
|
+ mPendingBroadcast.curApp);
|
|
boolean isDead;
|
if (mPendingBroadcast.curApp.pid > 0) {
|
synchronized (mService.mPidsSelfLocked) {
|
ProcessRecord proc = mService.mPidsSelfLocked.get(
|
mPendingBroadcast.curApp.pid);
|
isDead = proc == null || proc.isCrashing();
|
}
|
} else {
|
final ProcessRecord proc = mService.mProcessList.mProcessNames.get(
|
mPendingBroadcast.curApp.processName, mPendingBroadcast.curApp.uid);
|
isDead = proc == null || !proc.pendingStart;
|
}
|
if (!isDead) {
|
// It's still alive, so keep waiting
|
return;
|
} else {
|
Slog.w(TAG, "pending app ["
|
+ mQueueName + "]" + mPendingBroadcast.curApp
|
+ " died before responding to broadcast");
|
mPendingBroadcast.state = BroadcastRecord.IDLE;
|
mPendingBroadcast.nextReceiver = mPendingBroadcastRecvIndex;
|
mPendingBroadcast = null;
|
}
|
}
|
|
boolean looped = false;
|
|
do {
|
final long now = SystemClock.uptimeMillis();
|
r = mDispatcher.getNextBroadcastLocked(now);
|
|
if (r == null) {
|
// No more broadcasts are deliverable right now, so all done!
|
mDispatcher.scheduleDeferralCheckLocked(false);
|
mService.scheduleAppGcsLocked();
|
if (looped) {
|
// If we had finished the last ordered broadcast, then
|
// make sure all processes have correct oom and sched
|
// adjustments.
|
mService.updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_START_RECEIVER);
|
}
|
|
// when we have no more ordered broadcast on this queue, stop logging
|
if (mService.mUserController.mBootCompleted && mLogLatencyMetrics) {
|
mLogLatencyMetrics = false;
|
}
|
|
return;
|
}
|
|
boolean forceReceive = false;
|
|
// Ensure that even if something goes awry with the timeout
|
// detection, we catch "hung" broadcasts here, discard them,
|
// and continue to make progress.
|
//
|
// This is only done if the system is ready so that early-stage receivers
|
// don't get executed with timeouts; and of course other timeout-
|
// exempt broadcasts are ignored.
|
int numReceivers = (r.receivers != null) ? r.receivers.size() : 0;
|
if (mService.mProcessesReady && !r.timeoutExempt && r.dispatchTime > 0) {
|
if ((numReceivers > 0) &&
|
(now > r.dispatchTime + (2 * mConstants.TIMEOUT * numReceivers))) {
|
Slog.w(TAG, "Hung broadcast ["
|
+ mQueueName + "] discarded after timeout failure:"
|
+ " now=" + now
|
+ " dispatchTime=" + r.dispatchTime
|
+ " startTime=" + r.receiverTime
|
+ " intent=" + r.intent
|
+ " numReceivers=" + numReceivers
|
+ " nextReceiver=" + r.nextReceiver
|
+ " state=" + r.state);
|
broadcastTimeoutLocked(false); // forcibly finish this broadcast
|
forceReceive = true;
|
r.state = BroadcastRecord.IDLE;
|
}
|
}
|
|
if (r.state != BroadcastRecord.IDLE) {
|
if (DEBUG_BROADCAST) Slog.d(TAG_BROADCAST,
|
"processNextBroadcast("
|
+ mQueueName + ") called when not idle (state="
|
+ r.state + ")");
|
return;
|
}
|
|
// Is the current broadcast is done for any reason?
|
if (r.receivers == null || r.nextReceiver >= numReceivers
|
|| r.resultAbort || forceReceive) {
|
// Send the final result if requested
|
if (r.resultTo != null) {
|
boolean sendResult = true;
|
|
// if this was part of a split/deferral complex, update the refcount and only
|
// send the completion when we clear all of them
|
if (r.splitToken != 0) {
|
int newCount = mSplitRefcounts.get(r.splitToken) - 1;
|
if (newCount == 0) {
|
// done! clear out this record's bookkeeping and deliver
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST,
|
"Sending broadcast completion for split token "
|
+ r.splitToken + " : " + r.intent.getAction());
|
}
|
mSplitRefcounts.delete(r.splitToken);
|
} else {
|
// still have some split broadcast records in flight; update refcount
|
// and hold off on the callback
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST,
|
"Result refcount now " + newCount + " for split token "
|
+ r.splitToken + " : " + r.intent.getAction()
|
+ " - not sending completion yet");
|
}
|
sendResult = false;
|
mSplitRefcounts.put(r.splitToken, newCount);
|
}
|
}
|
if (sendResult) {
|
try {
|
if (DEBUG_BROADCAST) {
|
Slog.i(TAG_BROADCAST, "Finishing broadcast [" + mQueueName + "] "
|
+ r.intent.getAction() + " app=" + r.callerApp);
|
}
|
performReceiveLocked(r.callerApp, r.resultTo,
|
new Intent(r.intent), r.resultCode,
|
r.resultData, r.resultExtras, false, false, r.userId);
|
// Set this to null so that the reference
|
// (local and remote) isn't kept in the mBroadcastHistory.
|
r.resultTo = null;
|
} catch (RemoteException e) {
|
r.resultTo = null;
|
Slog.w(TAG, "Failure ["
|
+ mQueueName + "] sending broadcast result of "
|
+ r.intent, e);
|
}
|
}
|
}
|
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Cancelling BROADCAST_TIMEOUT_MSG");
|
cancelBroadcastTimeoutLocked();
|
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST,
|
"Finished with ordered broadcast " + r);
|
|
// ... and on to the next...
|
addBroadcastToHistoryLocked(r);
|
if (r.intent.getComponent() == null && r.intent.getPackage() == null
|
&& (r.intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) {
|
// This was an implicit broadcast... let's record it for posterity.
|
mService.addBroadcastStatLocked(r.intent.getAction(), r.callerPackage,
|
r.manifestCount, r.manifestSkipCount, r.finishTime-r.dispatchTime);
|
}
|
mDispatcher.retireBroadcastLocked(r);
|
r = null;
|
looped = true;
|
continue;
|
}
|
|
// Check whether the next receiver is under deferral policy, and handle that
|
// accordingly. If the current broadcast was already part of deferred-delivery
|
// tracking, we know that it must now be deliverable as-is without re-deferral.
|
if (!r.deferred) {
|
final int receiverUid = r.getReceiverUid(r.receivers.get(r.nextReceiver));
|
if (mDispatcher.isDeferringLocked(receiverUid)) {
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Next receiver in " + r + " uid " + receiverUid
|
+ " at " + r.nextReceiver + " is under deferral");
|
}
|
// If this is the only (remaining) receiver in the broadcast, "splitting"
|
// doesn't make sense -- just defer it as-is and retire it as the
|
// currently active outgoing broadcast.
|
BroadcastRecord defer;
|
if (r.nextReceiver + 1 == numReceivers) {
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Sole receiver of " + r
|
+ " is under deferral; setting aside and proceeding");
|
}
|
defer = r;
|
mDispatcher.retireBroadcastLocked(r);
|
} else {
|
// Nontrivial case; split out 'uid's receivers to a new broadcast record
|
// and defer that, then loop and pick up continuing delivery of the current
|
// record (now absent those receivers).
|
|
// The split operation is guaranteed to match at least at 'nextReceiver'
|
defer = r.splitRecipientsLocked(receiverUid, r.nextReceiver);
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "Post split:");
|
Slog.i(TAG_BROADCAST, "Original broadcast receivers:");
|
for (int i = 0; i < r.receivers.size(); i++) {
|
Slog.i(TAG_BROADCAST, " " + r.receivers.get(i));
|
}
|
Slog.i(TAG_BROADCAST, "Split receivers:");
|
for (int i = 0; i < defer.receivers.size(); i++) {
|
Slog.i(TAG_BROADCAST, " " + defer.receivers.get(i));
|
}
|
}
|
// Track completion refcount as well if relevant
|
if (r.resultTo != null) {
|
int token = r.splitToken;
|
if (token == 0) {
|
// first split of this record; refcount for 'r' and 'deferred'
|
r.splitToken = defer.splitToken = nextSplitTokenLocked();
|
mSplitRefcounts.put(r.splitToken, 2);
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST,
|
"Broadcast needs split refcount; using new token "
|
+ r.splitToken);
|
}
|
} else {
|
// new split from an already-refcounted situation; increment count
|
final int curCount = mSplitRefcounts.get(token);
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
if (curCount == 0) {
|
Slog.wtf(TAG_BROADCAST,
|
"Split refcount is zero with token for " + r);
|
}
|
}
|
mSplitRefcounts.put(token, curCount + 1);
|
if (DEBUG_BROADCAST_DEFERRAL) {
|
Slog.i(TAG_BROADCAST, "New split count for token " + token
|
+ " is " + (curCount + 1));
|
}
|
}
|
}
|
}
|
mDispatcher.addDeferredBroadcast(receiverUid, defer);
|
r = null;
|
looped = true;
|
continue;
|
}
|
}
|
} while (r == null);
|
|
// Get the next receiver...
|
int recIdx = r.nextReceiver++;
|
|
// Keep track of when this receiver started, and make sure there
|
// is a timeout message pending to kill it if need be.
|
r.receiverTime = SystemClock.uptimeMillis();
|
if (recIdx == 0) {
|
r.dispatchTime = r.receiverTime;
|
r.dispatchClockTime = System.currentTimeMillis();
|
|
if (mLogLatencyMetrics) {
|
StatsLog.write(
|
StatsLog.BROADCAST_DISPATCH_LATENCY_REPORTED,
|
r.dispatchClockTime - r.enqueueClockTime);
|
}
|
|
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
|
Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_PENDING),
|
System.identityHashCode(r));
|
Trace.asyncTraceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(r, BroadcastRecord.DELIVERY_DELIVERED),
|
System.identityHashCode(r));
|
}
|
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, "Processing ordered broadcast ["
|
+ mQueueName + "] " + r);
|
}
|
if (! mPendingBroadcastTimeoutMessage) {
|
long timeoutTime = r.receiverTime + mConstants.TIMEOUT;
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Submitting BROADCAST_TIMEOUT_MSG ["
|
+ mQueueName + "] for " + r + " at " + timeoutTime);
|
setBroadcastTimeoutLocked(timeoutTime);
|
}
|
|
final BroadcastOptions brOptions = r.options;
|
final Object nextReceiver = r.receivers.get(recIdx);
|
|
if (nextReceiver instanceof BroadcastFilter) {
|
// Simple case: this is a registered receiver who gets
|
// a direct call.
|
BroadcastFilter filter = (BroadcastFilter)nextReceiver;
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Delivering ordered ["
|
+ mQueueName + "] to registered "
|
+ filter + ": " + r);
|
deliverToRegisteredReceiverLocked(r, filter, r.ordered, recIdx);
|
if (r.receiver == null || !r.ordered) {
|
// The receiver has already finished, so schedule to
|
// process the next one.
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Quick finishing ["
|
+ mQueueName + "]: ordered="
|
+ r.ordered + " receiver=" + r.receiver);
|
r.state = BroadcastRecord.IDLE;
|
scheduleBroadcastsLocked();
|
} else {
|
if (filter.receiverList != null) {
|
maybeAddAllowBackgroundActivityStartsToken(filter.receiverList.app, r);
|
// r is guaranteed ordered at this point, so we know finishReceiverLocked()
|
// will get a callback and handle the activity start token lifecycle.
|
}
|
if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
|
scheduleTempWhitelistLocked(filter.owningUid,
|
brOptions.getTemporaryAppWhitelistDuration(), r);
|
}
|
}
|
return;
|
}
|
|
// Hard case: need to instantiate the receiver, possibly
|
// starting its application process to host it.
|
|
ResolveInfo info =
|
(ResolveInfo)nextReceiver;
|
ComponentName component = new ComponentName(
|
info.activityInfo.applicationInfo.packageName,
|
info.activityInfo.name);
|
|
boolean skip = false;
|
if (brOptions != null &&
|
(info.activityInfo.applicationInfo.targetSdkVersion
|
< brOptions.getMinManifestReceiverApiLevel() ||
|
info.activityInfo.applicationInfo.targetSdkVersion
|
> brOptions.getMaxManifestReceiverApiLevel())) {
|
skip = true;
|
}
|
if (!skip && !mService.validateAssociationAllowedLocked(r.callerPackage, r.callingUid,
|
component.getPackageName(), info.activityInfo.applicationInfo.uid)) {
|
Slog.w(TAG, "Association not allowed: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ") to " + component.flattenToShortString());
|
skip = true;
|
}
|
if (!skip) {
|
skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
|
r.callingPid, r.resolvedType, info.activityInfo.applicationInfo.uid);
|
if (skip) {
|
Slog.w(TAG, "Firewall blocked: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ") to " + component.flattenToShortString());
|
}
|
}
|
int perm = mService.checkComponentPermission(info.activityInfo.permission,
|
r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid,
|
info.activityInfo.exported);
|
if (!skip && perm != PackageManager.PERMISSION_GRANTED) {
|
if (!info.activityInfo.exported) {
|
Slog.w(TAG, "Permission Denial: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ")"
|
+ " is not exported from uid " + info.activityInfo.applicationInfo.uid
|
+ " due to receiver " + component.flattenToShortString());
|
} else {
|
Slog.w(TAG, "Permission Denial: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid=" + r.callingPid
|
+ ", uid=" + r.callingUid + ")"
|
+ " requires " + info.activityInfo.permission
|
+ " due to receiver " + component.flattenToShortString());
|
}
|
skip = true;
|
} else if (!skip && info.activityInfo.permission != null) {
|
final int opCode = AppOpsManager.permissionToOpCode(info.activityInfo.permission);
|
if (opCode != AppOpsManager.OP_NONE
|
&& mService.mAppOpsService.noteOperation(opCode, r.callingUid,
|
r.callerPackage) != AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: broadcasting "
|
+ r.intent.toString()
|
+ " from " + r.callerPackage + " (pid="
|
+ r.callingPid + ", uid=" + r.callingUid + ")"
|
+ " requires appop " + AppOpsManager.permissionToOp(
|
info.activityInfo.permission)
|
+ " due to registered receiver "
|
+ component.flattenToShortString());
|
skip = true;
|
}
|
}
|
if (!skip && info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID &&
|
r.requiredPermissions != null && r.requiredPermissions.length > 0) {
|
for (int i = 0; i < r.requiredPermissions.length; i++) {
|
String requiredPermission = r.requiredPermissions[i];
|
try {
|
perm = AppGlobals.getPackageManager().
|
checkPermission(requiredPermission,
|
info.activityInfo.applicationInfo.packageName,
|
UserHandle
|
.getUserId(info.activityInfo.applicationInfo.uid));
|
} catch (RemoteException e) {
|
perm = PackageManager.PERMISSION_DENIED;
|
}
|
if (perm != PackageManager.PERMISSION_GRANTED) {
|
Slog.w(TAG, "Permission Denial: receiving "
|
+ r.intent + " to "
|
+ component.flattenToShortString()
|
+ " requires " + requiredPermission
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
break;
|
}
|
int appOp = AppOpsManager.permissionToOpCode(requiredPermission);
|
if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp
|
&& mService.mAppOpsService.noteOperation(appOp,
|
info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
|
!= AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: receiving "
|
+ r.intent + " to "
|
+ component.flattenToShortString()
|
+ " requires appop " + AppOpsManager.permissionToOp(
|
requiredPermission)
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
break;
|
}
|
}
|
}
|
if (!skip && r.appOp != AppOpsManager.OP_NONE
|
&& mService.mAppOpsService.noteOperation(r.appOp,
|
info.activityInfo.applicationInfo.uid, info.activityInfo.packageName)
|
!= AppOpsManager.MODE_ALLOWED) {
|
Slog.w(TAG, "Appop Denial: receiving "
|
+ r.intent + " to "
|
+ component.flattenToShortString()
|
+ " requires appop " + AppOpsManager.opToName(r.appOp)
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
}
|
boolean isSingleton = false;
|
try {
|
isSingleton = mService.isSingleton(info.activityInfo.processName,
|
info.activityInfo.applicationInfo,
|
info.activityInfo.name, info.activityInfo.flags);
|
} catch (SecurityException e) {
|
Slog.w(TAG, e.getMessage());
|
skip = true;
|
}
|
if ((info.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) {
|
if (ActivityManager.checkUidPermission(
|
android.Manifest.permission.INTERACT_ACROSS_USERS,
|
info.activityInfo.applicationInfo.uid)
|
!= PackageManager.PERMISSION_GRANTED) {
|
Slog.w(TAG, "Permission Denial: Receiver " + component.flattenToShortString()
|
+ " requests FLAG_SINGLE_USER, but app does not hold "
|
+ android.Manifest.permission.INTERACT_ACROSS_USERS);
|
skip = true;
|
}
|
}
|
if (!skip && info.activityInfo.applicationInfo.isInstantApp()
|
&& r.callingUid != info.activityInfo.applicationInfo.uid) {
|
Slog.w(TAG, "Instant App Denial: receiving "
|
+ r.intent
|
+ " to " + component.flattenToShortString()
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")"
|
+ " Instant Apps do not support manifest receivers");
|
skip = true;
|
}
|
if (!skip && r.callerInstantApp
|
&& (info.activityInfo.flags & ActivityInfo.FLAG_VISIBLE_TO_INSTANT_APP) == 0
|
&& r.callingUid != info.activityInfo.applicationInfo.uid) {
|
Slog.w(TAG, "Instant App Denial: receiving "
|
+ r.intent
|
+ " to " + component.flattenToShortString()
|
+ " requires receiver have visibleToInstantApps set"
|
+ " due to sender " + r.callerPackage
|
+ " (uid " + r.callingUid + ")");
|
skip = true;
|
}
|
if (r.curApp != null && r.curApp.isCrashing()) {
|
// If the target process is crashing, just skip it.
|
Slog.w(TAG, "Skipping deliver ordered [" + mQueueName + "] " + r
|
+ " to " + r.curApp + ": process crashing");
|
skip = true;
|
}
|
if (!skip) {
|
boolean isAvailable = false;
|
try {
|
isAvailable = AppGlobals.getPackageManager().isPackageAvailable(
|
info.activityInfo.packageName,
|
UserHandle.getUserId(info.activityInfo.applicationInfo.uid));
|
} catch (Exception e) {
|
// all such failures mean we skip this receiver
|
Slog.w(TAG, "Exception getting recipient info for "
|
+ info.activityInfo.packageName, e);
|
}
|
if (!isAvailable) {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Skipping delivery to " + info.activityInfo.packageName + " / "
|
+ info.activityInfo.applicationInfo.uid
|
+ " : package no longer available");
|
skip = true;
|
}
|
}
|
|
// If permissions need a review before any of the app components can run, we drop
|
// the broadcast and if the calling app is in the foreground and the broadcast is
|
// explicit we launch the review UI passing it a pending intent to send the skipped
|
// broadcast.
|
if (!skip) {
|
if (!requestStartTargetPermissionsReviewIfNeededLocked(r,
|
info.activityInfo.packageName, UserHandle.getUserId(
|
info.activityInfo.applicationInfo.uid))) {
|
skip = true;
|
}
|
}
|
|
// This is safe to do even if we are skipping the broadcast, and we need
|
// this information now to evaluate whether it is going to be allowed to run.
|
final int receiverUid = info.activityInfo.applicationInfo.uid;
|
// If it's a singleton, it needs to be the same app or a special app
|
if (r.callingUid != Process.SYSTEM_UID && isSingleton
|
&& mService.isValidSingletonCall(r.callingUid, receiverUid)) {
|
info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0);
|
}
|
String targetProcess = info.activityInfo.processName;
|
ProcessRecord app = mService.getProcessRecordLocked(targetProcess,
|
info.activityInfo.applicationInfo.uid, false);
|
|
if (!skip) {
|
final int allowed = mService.getAppStartModeLocked(
|
info.activityInfo.applicationInfo.uid, info.activityInfo.packageName,
|
info.activityInfo.applicationInfo.targetSdkVersion, -1, true, false, false);
|
if (allowed != ActivityManager.APP_START_MODE_NORMAL) {
|
// We won't allow this receiver to be launched if the app has been
|
// completely disabled from launches, or it was not explicitly sent
|
// to it and the app is in a state that should not receive it
|
// (depending on how getAppStartModeLocked has determined that).
|
if (allowed == ActivityManager.APP_START_MODE_DISABLED) {
|
Slog.w(TAG, "Background execution disabled: receiving "
|
+ r.intent + " to "
|
+ component.flattenToShortString());
|
skip = true;
|
} else if (((r.intent.getFlags()&Intent.FLAG_RECEIVER_EXCLUDE_BACKGROUND) != 0)
|
|| (r.intent.getComponent() == null
|
&& r.intent.getPackage() == null
|
&& ((r.intent.getFlags()
|
& Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND) == 0)
|
&& !isSignaturePerm(r.requiredPermissions))) {
|
mService.addBackgroundCheckViolationLocked(r.intent.getAction(),
|
component.getPackageName());
|
Slog.w(TAG, "Background execution not allowed: receiving "
|
+ r.intent + " to "
|
+ component.flattenToShortString());
|
skip = true;
|
}
|
}
|
}
|
|
if (!skip && !Intent.ACTION_SHUTDOWN.equals(r.intent.getAction())
|
&& !mService.mUserController
|
.isUserRunning(UserHandle.getUserId(info.activityInfo.applicationInfo.uid),
|
0 /* flags */)) {
|
skip = true;
|
Slog.w(TAG,
|
"Skipping delivery to " + info.activityInfo.packageName + " / "
|
+ info.activityInfo.applicationInfo.uid + " : user is not running");
|
}
|
|
if (skip) {
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Skipping delivery of ordered [" + mQueueName + "] "
|
+ r + " for reason described above");
|
r.delivery[recIdx] = BroadcastRecord.DELIVERY_SKIPPED;
|
r.receiver = null;
|
r.curFilter = null;
|
r.state = BroadcastRecord.IDLE;
|
r.manifestSkipCount++;
|
scheduleBroadcastsLocked();
|
return;
|
}
|
r.manifestCount++;
|
|
r.delivery[recIdx] = BroadcastRecord.DELIVERY_DELIVERED;
|
r.state = BroadcastRecord.APP_RECEIVE;
|
r.curComponent = component;
|
r.curReceiver = info.activityInfo;
|
if (DEBUG_MU && r.callingUid > UserHandle.PER_USER_RANGE) {
|
Slog.v(TAG_MU, "Updated broadcast record activity info for secondary user, "
|
+ info.activityInfo + ", callingUid = " + r.callingUid + ", uid = "
|
+ receiverUid);
|
}
|
|
if (brOptions != null && brOptions.getTemporaryAppWhitelistDuration() > 0) {
|
scheduleTempWhitelistLocked(receiverUid,
|
brOptions.getTemporaryAppWhitelistDuration(), r);
|
}
|
|
// Broadcast is being executed, its package can't be stopped.
|
try {
|
AppGlobals.getPackageManager().setPackageStoppedState(
|
r.curComponent.getPackageName(), false, r.userId);
|
} catch (RemoteException e) {
|
} catch (IllegalArgumentException e) {
|
Slog.w(TAG, "Failed trying to unstop package "
|
+ r.curComponent.getPackageName() + ": " + e);
|
}
|
|
// Is this receiver's application already running?
|
if (app != null && app.thread != null && !app.killed) {
|
try {
|
app.addPackage(info.activityInfo.packageName,
|
info.activityInfo.applicationInfo.longVersionCode, mService.mProcessStats);
|
maybeAddAllowBackgroundActivityStartsToken(app, r);
|
processCurBroadcastLocked(r, app, skipOomAdj);
|
return;
|
} catch (RemoteException e) {
|
Slog.w(TAG, "Exception when sending broadcast to "
|
+ r.curComponent, e);
|
} catch (RuntimeException e) {
|
Slog.wtf(TAG, "Failed sending broadcast to "
|
+ r.curComponent + " with " + r.intent, e);
|
// If some unexpected exception happened, just skip
|
// this broadcast. At this point we are not in the call
|
// from a client, so throwing an exception out from here
|
// will crash the entire system instead of just whoever
|
// sent the broadcast.
|
logBroadcastReceiverDiscardLocked(r);
|
finishReceiverLocked(r, r.resultCode, r.resultData,
|
r.resultExtras, r.resultAbort, false);
|
scheduleBroadcastsLocked();
|
// We need to reset the state if we failed to start the receiver.
|
r.state = BroadcastRecord.IDLE;
|
return;
|
}
|
|
// If a dead object exception was thrown -- fall through to
|
// restart the application.
|
}
|
|
// Not running -- get it started, to be executed when the app comes up.
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Need to start app ["
|
+ mQueueName + "] " + targetProcess + " for broadcast " + r);
|
if ((r.curApp=mService.startProcessLocked(targetProcess,
|
info.activityInfo.applicationInfo, true,
|
r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND,
|
new HostingRecord("broadcast", r.curComponent),
|
(r.intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0, false, false))
|
== null) {
|
// Ah, this recipient is unavailable. Finish it if necessary,
|
// and mark the broadcast record as ready for the next.
|
Slog.w(TAG, "Unable to launch app "
|
+ info.activityInfo.applicationInfo.packageName + "/"
|
+ receiverUid + " for broadcast "
|
+ r.intent + ": process is bad");
|
logBroadcastReceiverDiscardLocked(r);
|
finishReceiverLocked(r, r.resultCode, r.resultData,
|
r.resultExtras, r.resultAbort, false);
|
scheduleBroadcastsLocked();
|
r.state = BroadcastRecord.IDLE;
|
return;
|
}
|
|
maybeAddAllowBackgroundActivityStartsToken(r.curApp, r);
|
mPendingBroadcast = r;
|
mPendingBroadcastRecvIndex = recIdx;
|
}
|
|
private void maybeAddAllowBackgroundActivityStartsToken(ProcessRecord proc, BroadcastRecord r) {
|
if (r == null || proc == null || !r.allowBackgroundActivityStarts) {
|
return;
|
}
|
String msgToken = (proc.toShortString() + r.toString()).intern();
|
// first, if there exists a past scheduled request to remove this token, drop
|
// that request - we don't want the token to be swept from under our feet...
|
mHandler.removeCallbacksAndMessages(msgToken);
|
// ...then add the token
|
proc.addAllowBackgroundActivityStartsToken(r);
|
}
|
|
final void setBroadcastTimeoutLocked(long timeoutTime) {
|
if (! mPendingBroadcastTimeoutMessage) {
|
Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG, this);
|
mHandler.sendMessageAtTime(msg, timeoutTime);
|
mPendingBroadcastTimeoutMessage = true;
|
}
|
}
|
|
final void cancelBroadcastTimeoutLocked() {
|
if (mPendingBroadcastTimeoutMessage) {
|
mHandler.removeMessages(BROADCAST_TIMEOUT_MSG, this);
|
mPendingBroadcastTimeoutMessage = false;
|
}
|
}
|
|
final void broadcastTimeoutLocked(boolean fromMsg) {
|
if (fromMsg) {
|
mPendingBroadcastTimeoutMessage = false;
|
}
|
|
if (mDispatcher.isEmpty() || mDispatcher.getActiveBroadcastLocked() == null) {
|
return;
|
}
|
|
long now = SystemClock.uptimeMillis();
|
BroadcastRecord r = mDispatcher.getActiveBroadcastLocked();
|
if (fromMsg) {
|
if (!mService.mProcessesReady) {
|
// Only process broadcast timeouts if the system is ready; some early
|
// broadcasts do heavy work setting up system facilities
|
return;
|
}
|
|
// If the broadcast is generally exempt from timeout tracking, we're done
|
if (r.timeoutExempt) {
|
if (DEBUG_BROADCAST) {
|
Slog.i(TAG_BROADCAST, "Broadcast timeout but it's exempt: "
|
+ r.intent.getAction());
|
}
|
return;
|
}
|
|
long timeoutTime = r.receiverTime + mConstants.TIMEOUT;
|
if (timeoutTime > now) {
|
// We can observe premature timeouts because we do not cancel and reset the
|
// broadcast timeout message after each receiver finishes. Instead, we set up
|
// an initial timeout then kick it down the road a little further as needed
|
// when it expires.
|
if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST,
|
"Premature timeout ["
|
+ mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for "
|
+ timeoutTime);
|
setBroadcastTimeoutLocked(timeoutTime);
|
return;
|
}
|
}
|
|
if (r.state == BroadcastRecord.WAITING_SERVICES) {
|
// In this case the broadcast had already finished, but we had decided to wait
|
// for started services to finish as well before going on. So if we have actually
|
// waited long enough time timeout the broadcast, let's give up on the whole thing
|
// and just move on to the next.
|
Slog.i(TAG, "Waited long enough for: " + (r.curComponent != null
|
? r.curComponent.flattenToShortString() : "(null)"));
|
r.curComponent = null;
|
r.state = BroadcastRecord.IDLE;
|
processNextBroadcast(false);
|
return;
|
}
|
|
// If the receiver app is being debugged we quietly ignore unresponsiveness, just
|
// tidying up and moving on to the next broadcast without crashing or ANRing this
|
// app just because it's stopped at a breakpoint.
|
final boolean debugging = (r.curApp != null && r.curApp.isDebugging());
|
|
Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver
|
+ ", started " + (now - r.receiverTime) + "ms ago");
|
r.receiverTime = now;
|
if (!debugging) {
|
r.anrCount++;
|
}
|
|
ProcessRecord app = null;
|
String anrMessage = null;
|
|
Object curReceiver;
|
if (r.nextReceiver > 0) {
|
curReceiver = r.receivers.get(r.nextReceiver-1);
|
r.delivery[r.nextReceiver-1] = BroadcastRecord.DELIVERY_TIMEOUT;
|
} else {
|
curReceiver = r.curReceiver;
|
}
|
Slog.w(TAG, "Receiver during timeout of " + r + " : " + curReceiver);
|
logBroadcastReceiverDiscardLocked(r);
|
if (curReceiver != null && curReceiver instanceof BroadcastFilter) {
|
BroadcastFilter bf = (BroadcastFilter)curReceiver;
|
if (bf.receiverList.pid != 0
|
&& bf.receiverList.pid != ActivityManagerService.MY_PID) {
|
synchronized (mService.mPidsSelfLocked) {
|
app = mService.mPidsSelfLocked.get(
|
bf.receiverList.pid);
|
}
|
}
|
} else {
|
app = r.curApp;
|
}
|
|
if (app != null) {
|
anrMessage = "Broadcast of " + r.intent.toString();
|
}
|
|
if (mPendingBroadcast == r) {
|
mPendingBroadcast = null;
|
}
|
|
// Move on to the next receiver.
|
finishReceiverLocked(r, r.resultCode, r.resultData,
|
r.resultExtras, r.resultAbort, false);
|
scheduleBroadcastsLocked();
|
|
if (!debugging && anrMessage != null) {
|
// Post the ANR to the handler since we do not want to process ANRs while
|
// potentially holding our lock.
|
mHandler.post(new AppNotResponding(app, anrMessage));
|
}
|
}
|
|
private final int ringAdvance(int x, final int increment, final int ringSize) {
|
x += increment;
|
if (x < 0) return (ringSize - 1);
|
else if (x >= ringSize) return 0;
|
else return x;
|
}
|
|
private final void addBroadcastToHistoryLocked(BroadcastRecord original) {
|
if (original.callingUid < 0) {
|
// This was from a registerReceiver() call; ignore it.
|
return;
|
}
|
original.finishTime = SystemClock.uptimeMillis();
|
|
if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
|
Trace.asyncTraceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER,
|
createBroadcastTraceTitle(original, BroadcastRecord.DELIVERY_DELIVERED),
|
System.identityHashCode(original));
|
}
|
|
// Note sometimes (only for sticky broadcasts?) we reuse BroadcastRecords,
|
// So don't change the incoming record directly.
|
final BroadcastRecord historyRecord = original.maybeStripForHistory();
|
|
mBroadcastHistory[mHistoryNext] = historyRecord;
|
mHistoryNext = ringAdvance(mHistoryNext, 1, MAX_BROADCAST_HISTORY);
|
|
mBroadcastSummaryHistory[mSummaryHistoryNext] = historyRecord.intent;
|
mSummaryHistoryEnqueueTime[mSummaryHistoryNext] = historyRecord.enqueueClockTime;
|
mSummaryHistoryDispatchTime[mSummaryHistoryNext] = historyRecord.dispatchClockTime;
|
mSummaryHistoryFinishTime[mSummaryHistoryNext] = System.currentTimeMillis();
|
mSummaryHistoryNext = ringAdvance(mSummaryHistoryNext, 1, MAX_BROADCAST_SUMMARY_HISTORY);
|
}
|
|
boolean cleanupDisabledPackageReceiversLocked(
|
String packageName, Set<String> filterByClasses, int userId, boolean doit) {
|
boolean didSomething = false;
|
for (int i = mParallelBroadcasts.size() - 1; i >= 0; i--) {
|
didSomething |= mParallelBroadcasts.get(i).cleanupDisabledPackageReceiversLocked(
|
packageName, filterByClasses, userId, doit);
|
if (!doit && didSomething) {
|
return true;
|
}
|
}
|
|
didSomething |= mDispatcher.cleanupDisabledPackageReceiversLocked(packageName,
|
filterByClasses, userId, doit);
|
|
return didSomething;
|
}
|
|
final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) {
|
final int logIndex = r.nextReceiver - 1;
|
if (logIndex >= 0 && logIndex < r.receivers.size()) {
|
Object curReceiver = r.receivers.get(logIndex);
|
if (curReceiver instanceof BroadcastFilter) {
|
BroadcastFilter bf = (BroadcastFilter) curReceiver;
|
EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER,
|
bf.owningUserId, System.identityHashCode(r),
|
r.intent.getAction(), logIndex, System.identityHashCode(bf));
|
} else {
|
ResolveInfo ri = (ResolveInfo) curReceiver;
|
EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
|
UserHandle.getUserId(ri.activityInfo.applicationInfo.uid),
|
System.identityHashCode(r), r.intent.getAction(), logIndex, ri.toString());
|
}
|
} else {
|
if (logIndex < 0) Slog.w(TAG,
|
"Discarding broadcast before first receiver is invoked: " + r);
|
EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_APP,
|
-1, System.identityHashCode(r),
|
r.intent.getAction(),
|
r.nextReceiver,
|
"NONE");
|
}
|
}
|
|
private String createBroadcastTraceTitle(BroadcastRecord record, int state) {
|
return String.format("Broadcast %s from %s (%s) %s",
|
state == BroadcastRecord.DELIVERY_PENDING ? "in queue" : "dispatched",
|
record.callerPackage == null ? "" : record.callerPackage,
|
record.callerApp == null ? "process unknown" : record.callerApp.toShortString(),
|
record.intent == null ? "" : record.intent.getAction());
|
}
|
|
boolean isIdle() {
|
return mParallelBroadcasts.isEmpty() && mDispatcher.isEmpty()
|
&& (mPendingBroadcast == null);
|
}
|
|
// Used by wait-for-broadcast-idle : fast-forward all current deferrals to
|
// be immediately deliverable.
|
void cancelDeferrals() {
|
synchronized (mService) {
|
mDispatcher.cancelDeferralsLocked();
|
scheduleBroadcastsLocked();
|
}
|
}
|
|
String describeState() {
|
synchronized (mService) {
|
return mParallelBroadcasts.size() + " parallel; "
|
+ mDispatcher.describeStateLocked();
|
}
|
}
|
|
void writeToProto(ProtoOutputStream proto, long fieldId) {
|
long token = proto.start(fieldId);
|
proto.write(BroadcastQueueProto.QUEUE_NAME, mQueueName);
|
int N;
|
N = mParallelBroadcasts.size();
|
for (int i = N - 1; i >= 0; i--) {
|
mParallelBroadcasts.get(i).writeToProto(proto, BroadcastQueueProto.PARALLEL_BROADCASTS);
|
}
|
mDispatcher.writeToProto(proto, BroadcastQueueProto.ORDERED_BROADCASTS);
|
if (mPendingBroadcast != null) {
|
mPendingBroadcast.writeToProto(proto, BroadcastQueueProto.PENDING_BROADCAST);
|
}
|
|
int lastIndex = mHistoryNext;
|
int ringIndex = lastIndex;
|
do {
|
// increasing index = more recent entry, and we want to print the most
|
// recent first and work backwards, so we roll through the ring backwards.
|
ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
|
BroadcastRecord r = mBroadcastHistory[ringIndex];
|
if (r != null) {
|
r.writeToProto(proto, BroadcastQueueProto.HISTORICAL_BROADCASTS);
|
}
|
} while (ringIndex != lastIndex);
|
|
lastIndex = ringIndex = mSummaryHistoryNext;
|
do {
|
ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
|
Intent intent = mBroadcastSummaryHistory[ringIndex];
|
if (intent == null) {
|
continue;
|
}
|
long summaryToken = proto.start(BroadcastQueueProto.HISTORICAL_BROADCASTS_SUMMARY);
|
intent.writeToProto(proto, BroadcastQueueProto.BroadcastSummary.INTENT,
|
false, true, true, false);
|
proto.write(BroadcastQueueProto.BroadcastSummary.ENQUEUE_CLOCK_TIME_MS,
|
mSummaryHistoryEnqueueTime[ringIndex]);
|
proto.write(BroadcastQueueProto.BroadcastSummary.DISPATCH_CLOCK_TIME_MS,
|
mSummaryHistoryDispatchTime[ringIndex]);
|
proto.write(BroadcastQueueProto.BroadcastSummary.FINISH_CLOCK_TIME_MS,
|
mSummaryHistoryFinishTime[ringIndex]);
|
proto.end(summaryToken);
|
} while (ringIndex != lastIndex);
|
proto.end(token);
|
}
|
|
final boolean dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args,
|
int opti, boolean dumpAll, String dumpPackage, boolean needSep) {
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
|
if (!mParallelBroadcasts.isEmpty() || !mDispatcher.isEmpty()
|
|| mPendingBroadcast != null) {
|
boolean printed = false;
|
for (int i = mParallelBroadcasts.size() - 1; i >= 0; i--) {
|
BroadcastRecord br = mParallelBroadcasts.get(i);
|
if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) {
|
continue;
|
}
|
if (!printed) {
|
if (needSep) {
|
pw.println();
|
}
|
needSep = true;
|
printed = true;
|
pw.println(" Active broadcasts [" + mQueueName + "]:");
|
}
|
pw.println(" Active Broadcast " + mQueueName + " #" + i + ":");
|
br.dump(pw, " ", sdf);
|
}
|
|
mDispatcher.dumpLocked(pw, dumpPackage, mQueueName, sdf);
|
|
if (dumpPackage == null || (mPendingBroadcast != null
|
&& dumpPackage.equals(mPendingBroadcast.callerPackage))) {
|
pw.println();
|
pw.println(" Pending broadcast [" + mQueueName + "]:");
|
if (mPendingBroadcast != null) {
|
mPendingBroadcast.dump(pw, " ", sdf);
|
} else {
|
pw.println(" (null)");
|
}
|
needSep = true;
|
}
|
}
|
|
mConstants.dump(pw);
|
|
int i;
|
boolean printed = false;
|
|
i = -1;
|
int lastIndex = mHistoryNext;
|
int ringIndex = lastIndex;
|
do {
|
// increasing index = more recent entry, and we want to print the most
|
// recent first and work backwards, so we roll through the ring backwards.
|
ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_HISTORY);
|
BroadcastRecord r = mBroadcastHistory[ringIndex];
|
if (r == null) {
|
continue;
|
}
|
|
i++; // genuine record of some sort even if we're filtering it out
|
if (dumpPackage != null && !dumpPackage.equals(r.callerPackage)) {
|
continue;
|
}
|
if (!printed) {
|
if (needSep) {
|
pw.println();
|
}
|
needSep = true;
|
pw.println(" Historical broadcasts [" + mQueueName + "]:");
|
printed = true;
|
}
|
if (dumpAll) {
|
pw.print(" Historical Broadcast " + mQueueName + " #");
|
pw.print(i); pw.println(":");
|
r.dump(pw, " ", sdf);
|
} else {
|
pw.print(" #"); pw.print(i); pw.print(": "); pw.println(r);
|
pw.print(" ");
|
pw.println(r.intent.toShortString(false, true, true, false));
|
if (r.targetComp != null && r.targetComp != r.intent.getComponent()) {
|
pw.print(" targetComp: "); pw.println(r.targetComp.toShortString());
|
}
|
Bundle bundle = r.intent.getExtras();
|
if (bundle != null) {
|
pw.print(" extras: "); pw.println(bundle.toString());
|
}
|
}
|
} while (ringIndex != lastIndex);
|
|
if (dumpPackage == null) {
|
lastIndex = ringIndex = mSummaryHistoryNext;
|
if (dumpAll) {
|
printed = false;
|
i = -1;
|
} else {
|
// roll over the 'i' full dumps that have already been issued
|
for (int j = i;
|
j > 0 && ringIndex != lastIndex;) {
|
ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
|
BroadcastRecord r = mBroadcastHistory[ringIndex];
|
if (r == null) {
|
continue;
|
}
|
j--;
|
}
|
}
|
// done skipping; dump the remainder of the ring. 'i' is still the ordinal within
|
// the overall broadcast history.
|
do {
|
ringIndex = ringAdvance(ringIndex, -1, MAX_BROADCAST_SUMMARY_HISTORY);
|
Intent intent = mBroadcastSummaryHistory[ringIndex];
|
if (intent == null) {
|
continue;
|
}
|
if (!printed) {
|
if (needSep) {
|
pw.println();
|
}
|
needSep = true;
|
pw.println(" Historical broadcasts summary [" + mQueueName + "]:");
|
printed = true;
|
}
|
if (!dumpAll && i >= 50) {
|
pw.println(" ...");
|
break;
|
}
|
i++;
|
pw.print(" #"); pw.print(i); pw.print(": ");
|
pw.println(intent.toShortString(false, true, true, false));
|
pw.print(" ");
|
TimeUtils.formatDuration(mSummaryHistoryDispatchTime[ringIndex]
|
- mSummaryHistoryEnqueueTime[ringIndex], pw);
|
pw.print(" dispatch ");
|
TimeUtils.formatDuration(mSummaryHistoryFinishTime[ringIndex]
|
- mSummaryHistoryDispatchTime[ringIndex], pw);
|
pw.println(" finish");
|
pw.print(" enq=");
|
pw.print(sdf.format(new Date(mSummaryHistoryEnqueueTime[ringIndex])));
|
pw.print(" disp=");
|
pw.print(sdf.format(new Date(mSummaryHistoryDispatchTime[ringIndex])));
|
pw.print(" fin=");
|
pw.println(sdf.format(new Date(mSummaryHistoryFinishTime[ringIndex])));
|
Bundle bundle = intent.getExtras();
|
if (bundle != null) {
|
pw.print(" extras: "); pw.println(bundle.toString());
|
}
|
} while (ringIndex != lastIndex);
|
}
|
|
return needSep;
|
}
|
}
|
