1198 lines
52 KiB
Java
1198 lines
52 KiB
Java
/*
|
||
* 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 java.io.FileDescriptor;
|
||
import java.io.PrintWriter;
|
||
import java.util.ArrayList;
|
||
|
||
import android.app.ActivityManager;
|
||
import android.app.AppGlobals;
|
||
import android.app.AppOpsManager;
|
||
import android.content.ComponentName;
|
||
import android.content.IIntentReceiver;
|
||
import android.content.Intent;
|
||
import android.content.pm.ActivityInfo;
|
||
import android.content.pm.PackageManager;
|
||
import android.content.pm.ResolveInfo;
|
||
import android.os.Bundle;
|
||
import android.os.Handler;
|
||
import android.os.IBinder;
|
||
import android.os.Message;
|
||
import android.os.Process;
|
||
import android.os.RemoteException;
|
||
import android.os.SystemClock;
|
||
import android.os.UserHandle;
|
||
import android.util.EventLog;
|
||
import android.util.Log;
|
||
import android.util.Slog;
|
||
|
||
/**
|
||
* BROADCASTS
|
||
*
|
||
* We keep two broadcast queues and associated bookkeeping, one for those at
|
||
* foreground priority, and one for normal (background-priority) broadcasts.
|
||
*/
|
||
public final class BroadcastQueue {
|
||
static final String TAG = "BroadcastQueue";
|
||
static final String TAG_MU = ActivityManagerService.TAG_MU;
|
||
static final boolean DEBUG_BROADCAST = ActivityManagerService.DEBUG_BROADCAST;
|
||
static final boolean DEBUG_BROADCAST_LIGHT = ActivityManagerService.DEBUG_BROADCAST_LIGHT;
|
||
static final boolean DEBUG_MU = ActivityManagerService.DEBUG_MU;
|
||
|
||
static final int MAX_BROADCAST_HISTORY = ActivityManager.isLowRamDeviceStatic() ? 10 : 50;
|
||
static final int MAX_BROADCAST_SUMMARY_HISTORY
|
||
= ActivityManager.isLowRamDeviceStatic() ? 25 : 300;
|
||
|
||
final ActivityManagerService mService;
|
||
|
||
/**
|
||
* Recognizable moniker for this queue
|
||
*/
|
||
final String mQueueName;
|
||
|
||
/**
|
||
* Timeout period for this queue's broadcasts
|
||
*/
|
||
final long mTimeoutPeriod;
|
||
|
||
/**
|
||
* 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<BroadcastRecord>();
|
||
|
||
/**
|
||
* List of all active broadcasts that are to be executed one at a time.
|
||
* The object at the top of the list is the currently activity broadcasts;
|
||
* those after it are waiting for the top to finish. As with parallel
|
||
* broadcasts, separate background- and foreground-priority queues are
|
||
* maintained.
|
||
*/
|
||
final ArrayList<BroadcastRecord> mOrderedBroadcasts = new ArrayList<BroadcastRecord>();
|
||
|
||
/**
|
||
* Historical data of past broadcasts, for debugging.
|
||
*/
|
||
final BroadcastRecord[] mBroadcastHistory = new BroadcastRecord[MAX_BROADCAST_HISTORY];
|
||
|
||
/**
|
||
* Summary of historical data of past broadcasts, for debugging.
|
||
*/
|
||
final Intent[] mBroadcastSummaryHistory = new Intent[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;
|
||
|
||
final Handler mHandler = new Handler() {
|
||
public void handleMessage(Message msg) {
|
||
switch (msg.what) {
|
||
case BROADCAST_INTENT_MSG: {
|
||
if (DEBUG_BROADCAST) Slog.v(
|
||
TAG, "Received BROADCAST_INTENT_MSG");
|
||
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() {
|
||
mService.appNotResponding(mApp, null, null, false, mAnnotation);
|
||
}
|
||
}
|
||
|
||
BroadcastQueue(ActivityManagerService service, String name, long timeoutPeriod,
|
||
boolean allowDelayBehindServices) {
|
||
mService = service;
|
||
mQueueName = name;
|
||
mTimeoutPeriod = timeoutPeriod;
|
||
mDelayBehindServices = allowDelayBehindServices;
|
||
}
|
||
|
||
public boolean isPendingBroadcastProcessLocked(int pid) {
|
||
return mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid;
|
||
}
|
||
|
||
public void enqueueParallelBroadcastLocked(BroadcastRecord r) {
|
||
mParallelBroadcasts.add(r);
|
||
}
|
||
|
||
public void enqueueOrderedBroadcastLocked(BroadcastRecord r) {
|
||
mOrderedBroadcasts.add(r);
|
||
}
|
||
|
||
public final boolean replaceParallelBroadcastLocked(BroadcastRecord r) {
|
||
for (int i=mParallelBroadcasts.size()-1; i>=0; i--) {
|
||
if (r.intent.filterEquals(mParallelBroadcasts.get(i).intent)) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"***** DROPPING PARALLEL ["
|
||
+ mQueueName + "]: " + r.intent);
|
||
mParallelBroadcasts.set(i, r);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public final boolean replaceOrderedBroadcastLocked(BroadcastRecord r) {
|
||
for (int i=mOrderedBroadcasts.size()-1; i>0; i--) {
|
||
if (r.intent.filterEquals(mOrderedBroadcasts.get(i).intent)) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"***** DROPPING ORDERED ["
|
||
+ mQueueName + "]: " + r.intent);
|
||
mOrderedBroadcasts.set(i, r);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private final void processCurBroadcastLocked(BroadcastRecord r,
|
||
ProcessRecord app) throws RemoteException {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Process cur broadcast " + r + " for app " + app);
|
||
if (app.thread == null) {
|
||
throw new RemoteException();
|
||
}
|
||
r.receiver = app.thread.asBinder();
|
||
r.curApp = app;
|
||
app.curReceiver = r;
|
||
app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_RECEIVER);
|
||
mService.updateLruProcessLocked(app, true, false);
|
||
|
||
// Tell the application to launch this receiver.
|
||
r.intent.setComponent(r.curComponent);
|
||
|
||
boolean started = false;
|
||
try {
|
||
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG,
|
||
"Delivering to component " + r.curComponent
|
||
+ ": " + r);
|
||
mService.ensurePackageDexOpt(r.intent.getComponent().getPackageName());
|
||
app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver,
|
||
mService.compatibilityInfoForPackageLocked(r.curReceiver.applicationInfo),
|
||
r.resultCode, r.resultData, r.resultExtras, r.ordered, r.userId,
|
||
app.repProcState);
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Process cur broadcast " + r + " DELIVERED for app " + app);
|
||
started = true;
|
||
} finally {
|
||
if (!started) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Process cur broadcast " + r + ": NOT STARTED!");
|
||
r.receiver = null;
|
||
r.curApp = null;
|
||
app.curReceiver = null;
|
||
}
|
||
}
|
||
}
|
||
|
||
public boolean sendPendingBroadcastsLocked(ProcessRecord app) {
|
||
boolean didSomething = false;
|
||
final BroadcastRecord br = mPendingBroadcast;
|
||
if (br != null && br.curApp.pid == app.pid) {
|
||
try {
|
||
mPendingBroadcast = null;
|
||
processCurBroadcastLocked(br, app);
|
||
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();
|
||
}
|
||
}
|
||
|
||
public void skipCurrentReceiverLocked(ProcessRecord app) {
|
||
boolean reschedule = false;
|
||
BroadcastRecord r = app.curReceiver;
|
||
if (r != null) {
|
||
// The current broadcast is waiting for this app's receiver
|
||
// to be finished. Looks like that's not going to happen, so
|
||
// let the broadcast continue.
|
||
logBroadcastReceiverDiscardLocked(r);
|
||
finishReceiverLocked(r, r.resultCode, r.resultData,
|
||
r.resultExtras, r.resultAbort, false);
|
||
reschedule = true;
|
||
}
|
||
|
||
r = mPendingBroadcast;
|
||
if (r != null && r.curApp == app) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"[" + mQueueName + "] skip & discard pending app " + r);
|
||
logBroadcastReceiverDiscardLocked(r);
|
||
finishReceiverLocked(r, r.resultCode, r.resultData,
|
||
r.resultExtras, r.resultAbort, false);
|
||
reschedule = true;
|
||
}
|
||
if (reschedule) {
|
||
scheduleBroadcastsLocked();
|
||
}
|
||
}
|
||
|
||
public void scheduleBroadcastsLocked() {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG, "Schedule broadcasts ["
|
||
+ mQueueName + "]: current="
|
||
+ mBroadcastsScheduled);
|
||
|
||
if (mBroadcastsScheduled) {
|
||
return;
|
||
}
|
||
mHandler.sendMessage(mHandler.obtainMessage(BROADCAST_INTENT_MSG, this));
|
||
mBroadcastsScheduled = true;
|
||
}
|
||
|
||
public BroadcastRecord getMatchingOrderedReceiver(IBinder receiver) {
|
||
if (mOrderedBroadcasts.size() > 0) {
|
||
final BroadcastRecord r = mOrderedBroadcasts.get(0);
|
||
if (r != null && r.receiver == receiver) {
|
||
return r;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
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;
|
||
r.state = BroadcastRecord.IDLE;
|
||
if (state == BroadcastRecord.IDLE) {
|
||
Slog.w(TAG, "finishReceiver [" + mQueueName + "] called but state is IDLE");
|
||
}
|
||
r.receiver = null;
|
||
r.intent.setComponent(null);
|
||
if (r.curApp != null) {
|
||
r.curApp.curReceiver = null;
|
||
}
|
||
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 (waitForServices && r.curComponent != null && r.queue.mDelayBehindServices
|
||
&& r.queue.mOrderedBroadcasts.size() > 0
|
||
&& r.queue.mOrderedBroadcasts.get(0) == 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.hasBackgroundServices(r.userId)) {
|
||
Slog.i(ActivityManagerService.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) {
|
||
if (mOrderedBroadcasts.size() > 0) {
|
||
BroadcastRecord br = mOrderedBroadcasts.get(0);
|
||
if (br.userId == userId && br.state == BroadcastRecord.WAITING_SERVICES) {
|
||
Slog.i(ActivityManagerService.TAG, "Resuming delayed broadcast");
|
||
br.curComponent = null;
|
||
br.state = BroadcastRecord.IDLE;
|
||
processNextBroadcast(false);
|
||
}
|
||
}
|
||
}
|
||
|
||
private static 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 && app.thread != null) {
|
||
// If we have an app thread, do the call through that so it is
|
||
// correctly ordered with other one-way calls.
|
||
app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode,
|
||
data, extras, ordered, sticky, sendingUser, app.repProcState);
|
||
} else {
|
||
receiver.performReceive(intent, resultCode, data, extras, ordered,
|
||
sticky, sendingUser);
|
||
}
|
||
}
|
||
|
||
private final void deliverToRegisteredReceiverLocked(BroadcastRecord r,
|
||
BroadcastFilter filter, boolean ordered) {
|
||
boolean skip = false;
|
||
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;
|
||
}
|
||
}
|
||
if (!skip && r.requiredPermission != null) {
|
||
int perm = mService.checkComponentPermission(r.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 " + r.requiredPermission
|
||
+ " due to sender " + r.callerPackage
|
||
+ " (uid " + r.callingUid + ")");
|
||
skip = true;
|
||
}
|
||
}
|
||
if (r.appOp != AppOpsManager.OP_NONE) {
|
||
int mode = mService.mAppOpsService.noteOperation(r.appOp,
|
||
filter.receiverList.uid, filter.packageName);
|
||
if (mode != AppOpsManager.MODE_ALLOWED) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"App op " + r.appOp + " not allowed for broadcast to uid "
|
||
+ filter.receiverList.uid + " pkg " + filter.packageName);
|
||
skip = true;
|
||
}
|
||
}
|
||
if (!skip) {
|
||
skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
|
||
r.callingPid, r.resolvedType, filter.receiverList.uid);
|
||
}
|
||
|
||
if (filter.receiverList.app == null || filter.receiverList.app.crashing) {
|
||
Slog.w(TAG, "Skipping deliver [" + mQueueName + "] " + r
|
||
+ " to " + filter.receiverList + ": process crashing");
|
||
skip = true;
|
||
}
|
||
|
||
if (!skip) {
|
||
// 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.curReceiver = r;
|
||
mService.updateOomAdjLocked(r.curApp, true);
|
||
}
|
||
}
|
||
try {
|
||
if (DEBUG_BROADCAST_LIGHT) {
|
||
int seq = r.intent.getIntExtra("seq", -1);
|
||
Slog.i(TAG, "Delivering to " + filter
|
||
+ " (seq=" + seq + "): " + r);
|
||
}
|
||
performReceiveLocked(filter.receiverList.app, filter.receiverList.receiver,
|
||
new Intent(r.intent), r.resultCode, r.resultData,
|
||
r.resultExtras, r.ordered, r.initialSticky, r.userId);
|
||
if (ordered) {
|
||
r.state = BroadcastRecord.CALL_DONE_RECEIVE;
|
||
}
|
||
} catch (RemoteException e) {
|
||
Slog.w(TAG, "Failure sending broadcast " + r.intent, e);
|
||
if (ordered) {
|
||
r.receiver = null;
|
||
r.curFilter = null;
|
||
filter.receiverList.curBroadcast = null;
|
||
if (filter.receiverList.app != null) {
|
||
filter.receiverList.app.curReceiver = null;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
final void processNextBroadcast(boolean fromMsg) {
|
||
synchronized(mService) {
|
||
BroadcastRecord r;
|
||
|
||
if (DEBUG_BROADCAST) Slog.v(TAG, "processNextBroadcast ["
|
||
+ mQueueName + "]: "
|
||
+ mParallelBroadcasts.size() + " broadcasts, "
|
||
+ mOrderedBroadcasts.size() + " ordered broadcasts");
|
||
|
||
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();
|
||
final int N = r.receivers.size();
|
||
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing parallel broadcast ["
|
||
+ mQueueName + "] " + r);
|
||
for (int i=0; i<N; i++) {
|
||
Object target = r.receivers.get(i);
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Delivering non-ordered on [" + mQueueName + "] to registered "
|
||
+ target + ": " + r);
|
||
deliverToRegisteredReceiverLocked(r, (BroadcastFilter)target, false);
|
||
}
|
||
addBroadcastToHistoryLocked(r);
|
||
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "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, "processNextBroadcast ["
|
||
+ mQueueName + "]: waiting for "
|
||
+ mPendingBroadcast.curApp);
|
||
}
|
||
|
||
boolean isDead;
|
||
synchronized (mService.mPidsSelfLocked) {
|
||
ProcessRecord proc = mService.mPidsSelfLocked.get(mPendingBroadcast.curApp.pid);
|
||
isDead = proc == null || proc.crashing;
|
||
}
|
||
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 {
|
||
if (mOrderedBroadcasts.size() == 0) {
|
||
// No more broadcasts pending, so all done!
|
||
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();
|
||
}
|
||
return;
|
||
}
|
||
r = mOrderedBroadcasts.get(0);
|
||
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 PRE_BOOT_COMPLETED
|
||
// receivers don't get executed with timeouts. They're intended for
|
||
// one time heavy lifting after system upgrades and can take
|
||
// significant amounts of time.
|
||
int numReceivers = (r.receivers != null) ? r.receivers.size() : 0;
|
||
if (mService.mProcessesReady && r.dispatchTime > 0) {
|
||
long now = SystemClock.uptimeMillis();
|
||
if ((numReceivers > 0) &&
|
||
(now > r.dispatchTime + (2*mTimeoutPeriod*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,
|
||
"processNextBroadcast("
|
||
+ mQueueName + ") called when not idle (state="
|
||
+ r.state + ")");
|
||
return;
|
||
}
|
||
|
||
if (r.receivers == null || r.nextReceiver >= numReceivers
|
||
|| r.resultAbort || forceReceive) {
|
||
// No more receivers for this broadcast! Send the final
|
||
// result if requested...
|
||
if (r.resultTo != null) {
|
||
try {
|
||
if (DEBUG_BROADCAST) {
|
||
int seq = r.intent.getIntExtra("seq", -1);
|
||
Slog.i(TAG, "Finishing broadcast ["
|
||
+ mQueueName + "] " + r.intent.getAction()
|
||
+ " seq=" + seq + " 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) {
|
||
Slog.w(TAG, "Failure ["
|
||
+ mQueueName + "] sending broadcast result of "
|
||
+ r.intent, e);
|
||
}
|
||
}
|
||
|
||
if (DEBUG_BROADCAST) Slog.v(TAG, "Cancelling BROADCAST_TIMEOUT_MSG");
|
||
cancelBroadcastTimeoutLocked();
|
||
|
||
if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Finished with ordered broadcast "
|
||
+ r);
|
||
|
||
// ... and on to the next...
|
||
addBroadcastToHistoryLocked(r);
|
||
mOrderedBroadcasts.remove(0);
|
||
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 (DEBUG_BROADCAST_LIGHT) Slog.v(TAG, "Processing ordered broadcast ["
|
||
+ mQueueName + "] " + r);
|
||
}
|
||
if (! mPendingBroadcastTimeoutMessage) {
|
||
long timeoutTime = r.receiverTime + mTimeoutPeriod;
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Submitting BROADCAST_TIMEOUT_MSG ["
|
||
+ mQueueName + "] for " + r + " at " + timeoutTime);
|
||
setBroadcastTimeoutLocked(timeoutTime);
|
||
}
|
||
|
||
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,
|
||
"Delivering ordered ["
|
||
+ mQueueName + "] to registered "
|
||
+ filter + ": " + r);
|
||
deliverToRegisteredReceiverLocked(r, filter, r.ordered);
|
||
if (r.receiver == null || !r.ordered) {
|
||
// The receiver has already finished, so schedule to
|
||
// process the next one.
|
||
if (DEBUG_BROADCAST) Slog.v(TAG, "Quick finishing ["
|
||
+ mQueueName + "]: ordered="
|
||
+ r.ordered + " receiver=" + r.receiver);
|
||
r.state = BroadcastRecord.IDLE;
|
||
scheduleBroadcastsLocked();
|
||
}
|
||
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;
|
||
int perm = mService.checkComponentPermission(info.activityInfo.permission,
|
||
r.callingPid, r.callingUid, info.activityInfo.applicationInfo.uid,
|
||
info.activityInfo.exported);
|
||
if (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;
|
||
}
|
||
if (info.activityInfo.applicationInfo.uid != Process.SYSTEM_UID &&
|
||
r.requiredPermission != null) {
|
||
try {
|
||
perm = AppGlobals.getPackageManager().
|
||
checkPermission(r.requiredPermission,
|
||
info.activityInfo.applicationInfo.packageName);
|
||
} catch (RemoteException e) {
|
||
perm = PackageManager.PERMISSION_DENIED;
|
||
}
|
||
if (perm != PackageManager.PERMISSION_GRANTED) {
|
||
Slog.w(TAG, "Permission Denial: receiving "
|
||
+ r.intent + " to "
|
||
+ component.flattenToShortString()
|
||
+ " requires " + r.requiredPermission
|
||
+ " due to sender " + r.callerPackage
|
||
+ " (uid " + r.callingUid + ")");
|
||
skip = true;
|
||
}
|
||
}
|
||
if (r.appOp != AppOpsManager.OP_NONE) {
|
||
int mode = mService.mAppOpsService.noteOperation(r.appOp,
|
||
info.activityInfo.applicationInfo.uid, info.activityInfo.packageName);
|
||
if (mode != AppOpsManager.MODE_ALLOWED) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"App op " + r.appOp + " not allowed for broadcast to uid "
|
||
+ info.activityInfo.applicationInfo.uid + " pkg "
|
||
+ info.activityInfo.packageName);
|
||
skip = true;
|
||
}
|
||
}
|
||
if (!skip) {
|
||
skip = !mService.mIntentFirewall.checkBroadcast(r.intent, r.callingUid,
|
||
r.callingPid, r.resolvedType, info.activityInfo.applicationInfo.uid);
|
||
}
|
||
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 (r.curApp != null && r.curApp.crashing) {
|
||
// 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) {
|
||
if (DEBUG_BROADCAST) Slog.v(TAG,
|
||
"Skipping delivery of ordered ["
|
||
+ mQueueName + "] " + r + " for whatever reason");
|
||
r.receiver = null;
|
||
r.curFilter = null;
|
||
r.state = BroadcastRecord.IDLE;
|
||
scheduleBroadcastsLocked();
|
||
return;
|
||
}
|
||
|
||
r.state = BroadcastRecord.APP_RECEIVE;
|
||
String targetProcess = info.activityInfo.processName;
|
||
r.curComponent = component;
|
||
if (r.callingUid != Process.SYSTEM_UID && isSingleton) {
|
||
info.activityInfo = mService.getActivityInfoForUser(info.activityInfo, 0);
|
||
}
|
||
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 = "
|
||
+ info.activityInfo.applicationInfo.uid);
|
||
}
|
||
|
||
// Broadcast is being executed, its package can't be stopped.
|
||
try {
|
||
AppGlobals.getPackageManager().setPackageStoppedState(
|
||
r.curComponent.getPackageName(), false, UserHandle.getUserId(r.callingUid));
|
||
} 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?
|
||
ProcessRecord app = mService.getProcessRecordLocked(targetProcess,
|
||
info.activityInfo.applicationInfo.uid, false);
|
||
if (app != null && app.thread != null) {
|
||
try {
|
||
app.addPackage(info.activityInfo.packageName, mService.mProcessStats);
|
||
processCurBroadcastLocked(r, app);
|
||
return;
|
||
} catch (RemoteException e) {
|
||
Slog.w(TAG, "Exception when sending broadcast to "
|
||
+ r.curComponent, e);
|
||
} catch (RuntimeException e) {
|
||
Log.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,
|
||
"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,
|
||
"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 + "/"
|
||
+ info.activityInfo.applicationInfo.uid + " 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;
|
||
}
|
||
|
||
mPendingBroadcast = r;
|
||
mPendingBroadcastRecvIndex = recIdx;
|
||
}
|
||
}
|
||
|
||
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 (mOrderedBroadcasts.size() == 0) {
|
||
return;
|
||
}
|
||
|
||
long now = SystemClock.uptimeMillis();
|
||
BroadcastRecord r = mOrderedBroadcasts.get(0);
|
||
if (fromMsg) {
|
||
if (mService.mDidDexOpt) {
|
||
// Delay timeouts until dexopt finishes.
|
||
mService.mDidDexOpt = false;
|
||
long timeoutTime = SystemClock.uptimeMillis() + mTimeoutPeriod;
|
||
setBroadcastTimeoutLocked(timeoutTime);
|
||
return;
|
||
}
|
||
if (!mService.mProcessesReady) {
|
||
// Only process broadcast timeouts if the system is ready. That way
|
||
// PRE_BOOT_COMPLETED broadcasts can't timeout as they are intended
|
||
// to do heavy lifting for system up.
|
||
return;
|
||
}
|
||
|
||
long timeoutTime = r.receiverTime + mTimeoutPeriod;
|
||
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,
|
||
"Premature timeout ["
|
||
+ mQueueName + "] @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for "
|
||
+ timeoutTime);
|
||
setBroadcastTimeoutLocked(timeoutTime);
|
||
return;
|
||
}
|
||
}
|
||
|
||
BroadcastRecord br = mOrderedBroadcasts.get(0);
|
||
if (br.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(ActivityManagerService.TAG, "Waited long enough for: " + (br.curComponent != null
|
||
? br.curComponent.flattenToShortString() : "(null)"));
|
||
br.curComponent = null;
|
||
br.state = BroadcastRecord.IDLE;
|
||
processNextBroadcast(false);
|
||
return;
|
||
}
|
||
|
||
Slog.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r. receiver
|
||
+ ", started " + (now - r.receiverTime) + "ms ago");
|
||
r.receiverTime = now;
|
||
r.anrCount++;
|
||
|
||
// Current receiver has passed its expiration date.
|
||
if (r.nextReceiver <= 0) {
|
||
Slog.w(TAG, "Timeout on receiver with nextReceiver <= 0");
|
||
return;
|
||
}
|
||
|
||
ProcessRecord app = null;
|
||
String anrMessage = null;
|
||
|
||
Object curReceiver = r.receivers.get(r.nextReceiver-1);
|
||
Slog.w(TAG, "Receiver during timeout: " + curReceiver);
|
||
logBroadcastReceiverDiscardLocked(r);
|
||
if (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 (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 void addBroadcastToHistoryLocked(BroadcastRecord r) {
|
||
if (r.callingUid < 0) {
|
||
// This was from a registerReceiver() call; ignore it.
|
||
return;
|
||
}
|
||
System.arraycopy(mBroadcastHistory, 0, mBroadcastHistory, 1,
|
||
MAX_BROADCAST_HISTORY-1);
|
||
r.finishTime = SystemClock.uptimeMillis();
|
||
mBroadcastHistory[0] = r;
|
||
System.arraycopy(mBroadcastSummaryHistory, 0, mBroadcastSummaryHistory, 1,
|
||
MAX_BROADCAST_SUMMARY_HISTORY-1);
|
||
mBroadcastSummaryHistory[0] = r.intent;
|
||
}
|
||
|
||
final void logBroadcastReceiverDiscardLocked(BroadcastRecord r) {
|
||
if (r.nextReceiver > 0) {
|
||
Object curReceiver = r.receivers.get(r.nextReceiver-1);
|
||
if (curReceiver instanceof BroadcastFilter) {
|
||
BroadcastFilter bf = (BroadcastFilter) curReceiver;
|
||
EventLog.writeEvent(EventLogTags.AM_BROADCAST_DISCARD_FILTER,
|
||
bf.owningUserId, System.identityHashCode(r),
|
||
r.intent.getAction(),
|
||
r.nextReceiver - 1,
|
||
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(),
|
||
r.nextReceiver - 1, ri.toString());
|
||
}
|
||
} else {
|
||
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");
|
||
}
|
||
}
|
||
|
||
final boolean dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args,
|
||
int opti, boolean dumpAll, String dumpPackage, boolean needSep) {
|
||
if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0
|
||
|| 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, " ");
|
||
}
|
||
printed = false;
|
||
needSep = true;
|
||
for (int i=mOrderedBroadcasts.size()-1; i>=0; i--) {
|
||
BroadcastRecord br = mOrderedBroadcasts.get(i);
|
||
if (dumpPackage != null && !dumpPackage.equals(br.callerPackage)) {
|
||
continue;
|
||
}
|
||
if (!printed) {
|
||
if (needSep) {
|
||
pw.println();
|
||
}
|
||
needSep = true;
|
||
printed = true;
|
||
pw.println(" Active ordered broadcasts [" + mQueueName + "]:");
|
||
}
|
||
pw.println(" Active Ordered Broadcast " + mQueueName + " #" + i + ":");
|
||
mOrderedBroadcasts.get(i).dump(pw, " ");
|
||
}
|
||
if (dumpPackage == null || (mPendingBroadcast != null
|
||
&& dumpPackage.equals(mPendingBroadcast.callerPackage))) {
|
||
if (needSep) {
|
||
pw.println();
|
||
}
|
||
pw.println(" Pending broadcast [" + mQueueName + "]:");
|
||
if (mPendingBroadcast != null) {
|
||
mPendingBroadcast.dump(pw, " ");
|
||
} else {
|
||
pw.println(" (null)");
|
||
}
|
||
needSep = true;
|
||
}
|
||
}
|
||
|
||
int i;
|
||
boolean printed = false;
|
||
for (i=0; i<MAX_BROADCAST_HISTORY; i++) {
|
||
BroadcastRecord r = mBroadcastHistory[i];
|
||
if (r == null) {
|
||
break;
|
||
}
|
||
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, " ");
|
||
} 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());
|
||
}
|
||
}
|
||
}
|
||
|
||
if (dumpPackage == null) {
|
||
if (dumpAll) {
|
||
i = 0;
|
||
printed = false;
|
||
}
|
||
for (; i<MAX_BROADCAST_SUMMARY_HISTORY; i++) {
|
||
Intent intent = mBroadcastSummaryHistory[i];
|
||
if (intent == null) {
|
||
break;
|
||
}
|
||
if (!printed) {
|
||
if (needSep) {
|
||
pw.println();
|
||
}
|
||
needSep = true;
|
||
pw.println(" Historical broadcasts summary [" + mQueueName + "]:");
|
||
printed = true;
|
||
}
|
||
if (!dumpAll && i >= 50) {
|
||
pw.println(" ...");
|
||
break;
|
||
}
|
||
pw.print(" #"); pw.print(i); pw.print(": ");
|
||
pw.println(intent.toShortString(false, true, true, false));
|
||
Bundle bundle = intent.getExtras();
|
||
if (bundle != null) {
|
||
pw.print(" extras: "); pw.println(bundle.toString());
|
||
}
|
||
}
|
||
}
|
||
|
||
return needSep;
|
||
}
|
||
}
|