| /* |
| * 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.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.permission.IPermissionManager; |
| import android.util.EventLog; |
| import android.util.Slog; |
| import android.util.SparseIntArray; |
| import android.util.TimeUtils; |
| import android.util.proto.ProtoOutputStream; |
| |
| import com.android.internal.util.FrameworkStatsLog; |
| |
| 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(app, 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(() -> { |
| synchronized (mService) { |
| 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); |
| // TODO moltmann: Set featureId from caller |
| if (opCode != AppOpsManager.OP_NONE |
| && mService.mAppOpsService.noteOperation(opCode, r.callingUid, |
| r.callerPackage, null, false, "") != 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); |
| // TODO moltmann: Set featureId from caller |
| if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp |
| && mService.mAppOpsService.noteOperation(appOp, |
| filter.receiverList.uid, filter.packageName, null, false, "") |
| != 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; |
| } |
| } |
| // TODO moltmann: Set featureId from caller |
| if (!skip && r.appOp != AppOpsManager.OP_NONE |
| && mService.mAppOpsService.noteOperation(r.appOp, |
| filter.receiverList.uid, filter.packageName, null, false, "") |
| != 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; |
| } |
| IPermissionManager pm = AppGlobals.getPermissionManager(); |
| 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) { |
| FrameworkStatsLog.write( |
| FrameworkStatsLog.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); |
| // TODO moltmann: Set featureId from caller |
| if (opCode != AppOpsManager.OP_NONE |
| && mService.mAppOpsService.noteOperation(opCode, r.callingUid, r.callerPackage, |
| null, false, "") != 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); |
| // TODO moltmann: Set featureId from caller |
| if (appOp != AppOpsManager.OP_NONE && appOp != r.appOp |
| && mService.mAppOpsService.noteOperation(appOp, |
| info.activityInfo.applicationInfo.uid, info.activityInfo.packageName, null, |
| false, "") |
| != 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; |
| } |
| } |
| } |
| // TODO moltmann: Set featureId from caller |
| if (!skip && r.appOp != AppOpsManager.OP_NONE |
| && mService.mAppOpsService.noteOperation(r.appOp, |
| info.activityInfo.applicationInfo.uid, info.activityInfo.packageName, null, false, |
| "") |
| != 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 dumpDebug(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).dumpDebug(proto, BroadcastQueueProto.PARALLEL_BROADCASTS); |
| } |
| mDispatcher.dumpDebug(proto, BroadcastQueueProto.ORDERED_BROADCASTS); |
| if (mPendingBroadcast != null) { |
| mPendingBroadcast.dumpDebug(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.dumpDebug(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.dumpDebug(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; |
| } |
| } |