ActivityManagerService.java revision 3007cc30f224f560081091159c6f706b2ed0e4bc
1/* 2 * Copyright (C) 2006-2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server.am; 18 19import static android.Manifest.permission.INTERACT_ACROSS_USERS; 20import static android.Manifest.permission.INTERACT_ACROSS_USERS_FULL; 21import static android.Manifest.permission.START_TASKS_FROM_RECENTS; 22import static android.content.pm.PackageManager.PERMISSION_GRANTED; 23import static com.android.internal.util.XmlUtils.readBooleanAttribute; 24import static com.android.internal.util.XmlUtils.readIntAttribute; 25import static com.android.internal.util.XmlUtils.readLongAttribute; 26import static com.android.internal.util.XmlUtils.writeBooleanAttribute; 27import static com.android.internal.util.XmlUtils.writeIntAttribute; 28import static com.android.internal.util.XmlUtils.writeLongAttribute; 29import static com.android.server.Watchdog.NATIVE_STACKS_OF_INTEREST; 30import static com.android.server.am.ActivityManagerDebugConfig.*; 31import static com.android.server.am.ActivityStackSupervisor.HOME_STACK_ID; 32import static com.android.server.am.TaskRecord.INVALID_TASK_ID; 33import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_DONT_LOCK; 34import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_LAUNCHABLE_PRIV; 35import static com.android.server.am.TaskRecord.LOCK_TASK_AUTH_PINNABLE; 36import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT; 37import static org.xmlpull.v1.XmlPullParser.START_TAG; 38 39import android.Manifest; 40import android.app.AppOpsManager; 41import android.app.ApplicationThreadNative; 42import android.app.BroadcastOptions; 43import android.app.IActivityContainer; 44import android.app.IActivityContainerCallback; 45import android.app.IAppTask; 46import android.app.ITaskStackListener; 47import android.app.ProfilerInfo; 48import android.app.assist.AssistContent; 49import android.app.assist.AssistStructure; 50import android.app.usage.UsageEvents; 51import android.app.usage.UsageStatsManagerInternal; 52import android.appwidget.AppWidgetManager; 53import android.content.pm.PermissionInfo; 54import android.content.res.Resources; 55import android.graphics.Bitmap; 56import android.graphics.Point; 57import android.graphics.Rect; 58import android.os.BatteryStats; 59import android.os.PersistableBundle; 60import android.os.PowerManager; 61import android.os.Trace; 62import android.os.TransactionTooLargeException; 63import android.os.WorkSource; 64import android.os.storage.IMountService; 65import android.os.storage.MountServiceInternal; 66import android.os.storage.StorageManager; 67import android.service.voice.IVoiceInteractionSession; 68import android.service.voice.VoiceInteractionSession; 69import android.util.ArrayMap; 70import android.util.ArraySet; 71import android.util.DebugUtils; 72import android.util.SparseIntArray; 73import android.view.Display; 74 75import com.android.internal.R; 76import com.android.internal.annotations.GuardedBy; 77import com.android.internal.app.AssistUtils; 78import com.android.internal.app.DumpHeapActivity; 79import com.android.internal.app.IAppOpsService; 80import com.android.internal.app.IVoiceInteractor; 81import com.android.internal.app.ProcessMap; 82import com.android.internal.app.ProcessStats; 83import com.android.internal.os.BackgroundThread; 84import com.android.internal.os.BatteryStatsImpl; 85import com.android.internal.os.IResultReceiver; 86import com.android.internal.os.ProcessCpuTracker; 87import com.android.internal.os.TransferPipe; 88import com.android.internal.os.Zygote; 89import com.android.internal.util.ArrayUtils; 90import com.android.internal.util.FastPrintWriter; 91import com.android.internal.util.FastXmlSerializer; 92import com.android.internal.util.MemInfoReader; 93import com.android.internal.util.Preconditions; 94import com.android.server.AppOpsService; 95import com.android.server.AttributeCache; 96import com.android.server.DeviceIdleController; 97import com.android.server.IntentResolver; 98import com.android.server.LocalServices; 99import com.android.server.ServiceThread; 100import com.android.server.SystemService; 101import com.android.server.SystemServiceManager; 102import com.android.server.Watchdog; 103import com.android.server.am.ActivityStack.ActivityState; 104import com.android.server.firewall.IntentFirewall; 105import com.android.server.pm.Installer; 106import com.android.server.pm.UserManagerService; 107import com.android.server.statusbar.StatusBarManagerInternal; 108import com.android.server.wm.AppTransition; 109import com.android.server.wm.WindowManagerService; 110import com.google.android.collect.Lists; 111import com.google.android.collect.Maps; 112 113import libcore.io.IoUtils; 114import libcore.util.EmptyArray; 115 116import org.xmlpull.v1.XmlPullParser; 117import org.xmlpull.v1.XmlPullParserException; 118import org.xmlpull.v1.XmlSerializer; 119 120import android.app.Activity; 121import android.app.ActivityManager; 122import android.app.ActivityManager.RunningTaskInfo; 123import android.app.ActivityManager.StackInfo; 124import android.app.ActivityManagerInternal; 125import android.app.ActivityManagerInternal.SleepToken; 126import android.app.ActivityManagerNative; 127import android.app.ActivityOptions; 128import android.app.ActivityThread; 129import android.app.AlertDialog; 130import android.app.AppGlobals; 131import android.app.ApplicationErrorReport; 132import android.app.Dialog; 133import android.app.IActivityController; 134import android.app.IApplicationThread; 135import android.app.IInstrumentationWatcher; 136import android.app.INotificationManager; 137import android.app.IProcessObserver; 138import android.app.IServiceConnection; 139import android.app.IStopUserCallback; 140import android.app.IUidObserver; 141import android.app.IUiAutomationConnection; 142import android.app.IUserSwitchObserver; 143import android.app.Instrumentation; 144import android.app.Notification; 145import android.app.NotificationManager; 146import android.app.PendingIntent; 147import android.app.backup.IBackupManager; 148import android.app.admin.DevicePolicyManager; 149import android.content.ActivityNotFoundException; 150import android.content.BroadcastReceiver; 151import android.content.ClipData; 152import android.content.ComponentCallbacks2; 153import android.content.ComponentName; 154import android.content.ContentProvider; 155import android.content.ContentResolver; 156import android.content.Context; 157import android.content.DialogInterface; 158import android.content.IContentProvider; 159import android.content.IIntentReceiver; 160import android.content.IIntentSender; 161import android.content.Intent; 162import android.content.IntentFilter; 163import android.content.IntentSender; 164import android.content.pm.ActivityInfo; 165import android.content.pm.ApplicationInfo; 166import android.content.pm.ConfigurationInfo; 167import android.content.pm.IPackageDataObserver; 168import android.content.pm.IPackageManager; 169import android.content.pm.InstrumentationInfo; 170import android.content.pm.PackageInfo; 171import android.content.pm.PackageManager; 172import android.content.pm.ParceledListSlice; 173import android.content.pm.UserInfo; 174import android.content.pm.PackageManager.NameNotFoundException; 175import android.content.pm.PathPermission; 176import android.content.pm.ProviderInfo; 177import android.content.pm.ResolveInfo; 178import android.content.pm.ServiceInfo; 179import android.content.res.CompatibilityInfo; 180import android.content.res.Configuration; 181import android.net.Proxy; 182import android.net.ProxyInfo; 183import android.net.Uri; 184import android.os.Binder; 185import android.os.Build; 186import android.os.Bundle; 187import android.os.Debug; 188import android.os.DropBoxManager; 189import android.os.Environment; 190import android.os.FactoryTest; 191import android.os.FileObserver; 192import android.os.FileUtils; 193import android.os.Handler; 194import android.os.IBinder; 195import android.os.IPermissionController; 196import android.os.IProcessInfoService; 197import android.os.IRemoteCallback; 198import android.os.IUserManager; 199import android.os.Looper; 200import android.os.Message; 201import android.os.Parcel; 202import android.os.ParcelFileDescriptor; 203import android.os.PowerManagerInternal; 204import android.os.Process; 205import android.os.RemoteCallbackList; 206import android.os.RemoteException; 207import android.os.SELinux; 208import android.os.ServiceManager; 209import android.os.StrictMode; 210import android.os.SystemClock; 211import android.os.SystemProperties; 212import android.os.UpdateLock; 213import android.os.UserHandle; 214import android.os.UserManager; 215import android.provider.Settings; 216import android.text.format.DateUtils; 217import android.text.format.Time; 218import android.util.AtomicFile; 219import android.util.EventLog; 220import android.util.Log; 221import android.util.Pair; 222import android.util.PrintWriterPrinter; 223import android.util.Slog; 224import android.util.SparseArray; 225import android.util.TimeUtils; 226import android.util.Xml; 227import android.view.Gravity; 228import android.view.LayoutInflater; 229import android.view.View; 230import android.view.WindowManager; 231 232import dalvik.system.VMRuntime; 233 234import java.io.BufferedInputStream; 235import java.io.BufferedOutputStream; 236import java.io.DataInputStream; 237import java.io.DataOutputStream; 238import java.io.File; 239import java.io.FileDescriptor; 240import java.io.FileInputStream; 241import java.io.FileNotFoundException; 242import java.io.FileOutputStream; 243import java.io.IOException; 244import java.io.InputStreamReader; 245import java.io.PrintWriter; 246import java.io.StringWriter; 247import java.lang.ref.WeakReference; 248import java.nio.charset.StandardCharsets; 249import java.util.ArrayList; 250import java.util.Arrays; 251import java.util.Collections; 252import java.util.Comparator; 253import java.util.HashMap; 254import java.util.HashSet; 255import java.util.Iterator; 256import java.util.List; 257import java.util.Locale; 258import java.util.Map; 259import java.util.Set; 260import java.util.concurrent.atomic.AtomicBoolean; 261import java.util.concurrent.atomic.AtomicLong; 262 263public final class ActivityManagerService extends ActivityManagerNative 264 implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback { 265 266 // File that stores last updated system version and called preboot receivers 267 static final String CALLED_PRE_BOOTS_FILENAME = "called_pre_boots.dat"; 268 269 private static final String TAG = TAG_WITH_CLASS_NAME ? "ActivityManagerService" : TAG_AM; 270 private static final String TAG_BACKUP = TAG + POSTFIX_BACKUP; 271 private static final String TAG_BROADCAST = TAG + POSTFIX_BROADCAST; 272 private static final String TAG_CLEANUP = TAG + POSTFIX_CLEANUP; 273 private static final String TAG_CONFIGURATION = TAG + POSTFIX_CONFIGURATION; 274 private static final String TAG_FOCUS = TAG + POSTFIX_FOCUS; 275 private static final String TAG_IMMERSIVE = TAG + POSTFIX_IMMERSIVE; 276 private static final String TAG_LOCKSCREEN = TAG + POSTFIX_LOCKSCREEN; 277 private static final String TAG_LOCKTASK = TAG + POSTFIX_LOCKTASK; 278 private static final String TAG_LRU = TAG + POSTFIX_LRU; 279 private static final String TAG_MU = TAG + POSTFIX_MU; 280 private static final String TAG_OOM_ADJ = TAG + POSTFIX_OOM_ADJ; 281 private static final String TAG_POWER = TAG + POSTFIX_POWER; 282 private static final String TAG_PROCESS_OBSERVERS = TAG + POSTFIX_PROCESS_OBSERVERS; 283 private static final String TAG_PROCESSES = TAG + POSTFIX_PROCESSES; 284 private static final String TAG_PROVIDER = TAG + POSTFIX_PROVIDER; 285 private static final String TAG_PSS = TAG + POSTFIX_PSS; 286 private static final String TAG_RECENTS = TAG + POSTFIX_RECENTS; 287 private static final String TAG_SERVICE = TAG + POSTFIX_SERVICE; 288 private static final String TAG_STACK = TAG + POSTFIX_STACK; 289 private static final String TAG_SWITCH = TAG + POSTFIX_SWITCH; 290 private static final String TAG_UID_OBSERVERS = TAG + POSTFIX_UID_OBSERVERS; 291 private static final String TAG_URI_PERMISSION = TAG + POSTFIX_URI_PERMISSION; 292 private static final String TAG_VISIBILITY = TAG + POSTFIX_VISIBILITY; 293 private static final String TAG_VISIBLE_BEHIND = TAG + POSTFIX_VISIBLE_BEHIND; 294 295 /** Control over CPU and battery monitoring */ 296 // write battery stats every 30 minutes. 297 static final long BATTERY_STATS_TIME = 30 * 60 * 1000; 298 static final boolean MONITOR_CPU_USAGE = true; 299 // don't sample cpu less than every 5 seconds. 300 static final long MONITOR_CPU_MIN_TIME = 5 * 1000; 301 // wait possibly forever for next cpu sample. 302 static final long MONITOR_CPU_MAX_TIME = 0x0fffffff; 303 static final boolean MONITOR_THREAD_CPU_USAGE = false; 304 305 // The flags that are set for all calls we make to the package manager. 306 static final int STOCK_PM_FLAGS = PackageManager.GET_SHARED_LIBRARY_FILES; 307 308 private static final String SYSTEM_DEBUGGABLE = "ro.debuggable"; 309 310 static final boolean IS_USER_BUILD = "user".equals(Build.TYPE); 311 312 // Amount of time after a call to stopAppSwitches() during which we will 313 // prevent further untrusted switches from happening. 314 static final long APP_SWITCH_DELAY_TIME = 5*1000; 315 316 // How long we wait for a launched process to attach to the activity manager 317 // before we decide it's never going to come up for real. 318 static final int PROC_START_TIMEOUT = 10*1000; 319 320 // How long we wait for a launched process to attach to the activity manager 321 // before we decide it's never going to come up for real, when the process was 322 // started with a wrapper for instrumentation (such as Valgrind) because it 323 // could take much longer than usual. 324 static final int PROC_START_TIMEOUT_WITH_WRAPPER = 1200*1000; 325 326 // How long to wait after going idle before forcing apps to GC. 327 static final int GC_TIMEOUT = 5*1000; 328 329 // The minimum amount of time between successive GC requests for a process. 330 static final int GC_MIN_INTERVAL = 60*1000; 331 332 // The minimum amount of time between successive PSS requests for a process. 333 static final int FULL_PSS_MIN_INTERVAL = 10*60*1000; 334 335 // The minimum amount of time between successive PSS requests for a process 336 // when the request is due to the memory state being lowered. 337 static final int FULL_PSS_LOWERED_INTERVAL = 2*60*1000; 338 339 // The rate at which we check for apps using excessive power -- 15 mins. 340 static final int POWER_CHECK_DELAY = (DEBUG_POWER_QUICK ? 2 : 15) * 60*1000; 341 342 // The minimum sample duration we will allow before deciding we have 343 // enough data on wake locks to start killing things. 344 static final int WAKE_LOCK_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000; 345 346 // The minimum sample duration we will allow before deciding we have 347 // enough data on CPU usage to start killing things. 348 static final int CPU_MIN_CHECK_DURATION = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000; 349 350 // How long we allow a receiver to run before giving up on it. 351 static final int BROADCAST_FG_TIMEOUT = 10*1000; 352 static final int BROADCAST_BG_TIMEOUT = 60*1000; 353 354 // How long we wait until we timeout on key dispatching. 355 static final int KEY_DISPATCHING_TIMEOUT = 5*1000; 356 357 // How long we wait until we timeout on key dispatching during instrumentation. 358 static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT = 60*1000; 359 360 // Amount of time we wait for observers to handle a user switch before 361 // giving up on them and unfreezing the screen. 362 static final int USER_SWITCH_TIMEOUT = 2*1000; 363 364 // This is the amount of time an app needs to be running a foreground service before 365 // we will consider it to be doing interaction for usage stats. 366 static final int SERVICE_USAGE_INTERACTION_TIME = 30*60*1000; 367 368 // Maximum number of users we allow to be running at a time. 369 static final int MAX_RUNNING_USERS = 3; 370 371 // How long to wait in getAssistContextExtras for the activity and foreground services 372 // to respond with the result. 373 static final int PENDING_ASSIST_EXTRAS_TIMEOUT = 500; 374 375 // How long top wait when going through the modern assist (which doesn't need to block 376 // on getting this result before starting to launch its UI). 377 static final int PENDING_ASSIST_EXTRAS_LONG_TIMEOUT = 2000; 378 379 // Maximum number of persisted Uri grants a package is allowed 380 static final int MAX_PERSISTED_URI_GRANTS = 128; 381 382 static final int MY_PID = Process.myPid(); 383 384 static final String[] EMPTY_STRING_ARRAY = new String[0]; 385 386 // How many bytes to write into the dropbox log before truncating 387 static final int DROPBOX_MAX_SIZE = 256 * 1024; 388 389 // Access modes for handleIncomingUser. 390 static final int ALLOW_NON_FULL = 0; 391 static final int ALLOW_NON_FULL_IN_PROFILE = 1; 392 static final int ALLOW_FULL_ONLY = 2; 393 394 static final int LAST_PREBOOT_DELIVERED_FILE_VERSION = 10000; 395 396 // Delay in notifying task stack change listeners (in millis) 397 static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_DELAY = 1000; 398 399 // Necessary ApplicationInfo flags to mark an app as persistent 400 private static final int PERSISTENT_MASK = 401 ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT; 402 403 /** All system services */ 404 SystemServiceManager mSystemServiceManager; 405 406 private Installer mInstaller; 407 408 /** Run all ActivityStacks through this */ 409 ActivityStackSupervisor mStackSupervisor; 410 411 /** Task stack change listeners. */ 412 private RemoteCallbackList<ITaskStackListener> mTaskStackListeners = 413 new RemoteCallbackList<ITaskStackListener>(); 414 415 public IntentFirewall mIntentFirewall; 416 417 // Whether we should show our dialogs (ANR, crash, etc) or just perform their 418 // default actuion automatically. Important for devices without direct input 419 // devices. 420 private boolean mShowDialogs = true; 421 422 BroadcastQueue mFgBroadcastQueue; 423 BroadcastQueue mBgBroadcastQueue; 424 // Convenient for easy iteration over the queues. Foreground is first 425 // so that dispatch of foreground broadcasts gets precedence. 426 final BroadcastQueue[] mBroadcastQueues = new BroadcastQueue[2]; 427 428 BroadcastQueue broadcastQueueForIntent(Intent intent) { 429 final boolean isFg = (intent.getFlags() & Intent.FLAG_RECEIVER_FOREGROUND) != 0; 430 if (DEBUG_BROADCAST_BACKGROUND) Slog.i(TAG_BROADCAST, 431 "Broadcast intent " + intent + " on " 432 + (isFg ? "foreground" : "background") + " queue"); 433 return (isFg) ? mFgBroadcastQueue : mBgBroadcastQueue; 434 } 435 436 /** 437 * Activity we have told the window manager to have key focus. 438 */ 439 ActivityRecord mFocusedActivity = null; 440 441 /** 442 * User id of the last activity mFocusedActivity was set to. 443 */ 444 private int mLastFocusedUserId; 445 446 /** 447 * If non-null, we are tracking the time the user spends in the currently focused app. 448 */ 449 private AppTimeTracker mCurAppTimeTracker; 450 451 /** 452 * List of intents that were used to start the most recent tasks. 453 */ 454 private final RecentTasks mRecentTasks; 455 456 /** 457 * For addAppTask: cached of the last activity component that was added. 458 */ 459 ComponentName mLastAddedTaskComponent; 460 461 /** 462 * For addAppTask: cached of the last activity uid that was added. 463 */ 464 int mLastAddedTaskUid; 465 466 /** 467 * For addAppTask: cached of the last ActivityInfo that was added. 468 */ 469 ActivityInfo mLastAddedTaskActivity; 470 471 /** 472 * List of packages whitelisted by DevicePolicyManager for locktask. Indexed by userId. 473 */ 474 SparseArray<String[]> mLockTaskPackages = new SparseArray<>(); 475 476 /** 477 * The package name of the DeviceOwner. This package is not permitted to have its data cleared. 478 */ 479 String mDeviceOwnerName; 480 481 public class PendingAssistExtras extends Binder implements Runnable { 482 public final ActivityRecord activity; 483 public final Bundle extras; 484 public final Intent intent; 485 public final String hint; 486 public final IResultReceiver receiver; 487 public final int userHandle; 488 public boolean haveResult = false; 489 public Bundle result = null; 490 public AssistStructure structure = null; 491 public AssistContent content = null; 492 public PendingAssistExtras(ActivityRecord _activity, Bundle _extras, Intent _intent, 493 String _hint, IResultReceiver _receiver, int _userHandle) { 494 activity = _activity; 495 extras = _extras; 496 intent = _intent; 497 hint = _hint; 498 receiver = _receiver; 499 userHandle = _userHandle; 500 } 501 @Override 502 public void run() { 503 Slog.w(TAG, "getAssistContextExtras failed: timeout retrieving from " + activity); 504 synchronized (this) { 505 haveResult = true; 506 notifyAll(); 507 } 508 pendingAssistExtrasTimedOut(this); 509 } 510 } 511 512 final ArrayList<PendingAssistExtras> mPendingAssistExtras 513 = new ArrayList<PendingAssistExtras>(); 514 515 /** 516 * Process management. 517 */ 518 final ProcessList mProcessList = new ProcessList(); 519 520 /** 521 * All of the applications we currently have running organized by name. 522 * The keys are strings of the application package name (as 523 * returned by the package manager), and the keys are ApplicationRecord 524 * objects. 525 */ 526 final ProcessMap<ProcessRecord> mProcessNames = new ProcessMap<ProcessRecord>(); 527 528 /** 529 * Tracking long-term execution of processes to look for abuse and other 530 * bad app behavior. 531 */ 532 final ProcessStatsService mProcessStats; 533 534 /** 535 * The currently running isolated processes. 536 */ 537 final SparseArray<ProcessRecord> mIsolatedProcesses = new SparseArray<ProcessRecord>(); 538 539 /** 540 * Counter for assigning isolated process uids, to avoid frequently reusing the 541 * same ones. 542 */ 543 int mNextIsolatedProcessUid = 0; 544 545 /** 546 * The currently running heavy-weight process, if any. 547 */ 548 ProcessRecord mHeavyWeightProcess = null; 549 550 /** 551 * The last time that various processes have crashed. 552 */ 553 final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<Long>(); 554 555 /** 556 * Information about a process that is currently marked as bad. 557 */ 558 static final class BadProcessInfo { 559 BadProcessInfo(long time, String shortMsg, String longMsg, String stack) { 560 this.time = time; 561 this.shortMsg = shortMsg; 562 this.longMsg = longMsg; 563 this.stack = stack; 564 } 565 566 final long time; 567 final String shortMsg; 568 final String longMsg; 569 final String stack; 570 } 571 572 /** 573 * Set of applications that we consider to be bad, and will reject 574 * incoming broadcasts from (which the user has no control over). 575 * Processes are added to this set when they have crashed twice within 576 * a minimum amount of time; they are removed from it when they are 577 * later restarted (hopefully due to some user action). The value is the 578 * time it was added to the list. 579 */ 580 final ProcessMap<BadProcessInfo> mBadProcesses = new ProcessMap<BadProcessInfo>(); 581 582 /** 583 * All of the processes we currently have running organized by pid. 584 * The keys are the pid running the application. 585 * 586 * <p>NOTE: This object is protected by its own lock, NOT the global 587 * activity manager lock! 588 */ 589 final SparseArray<ProcessRecord> mPidsSelfLocked = new SparseArray<ProcessRecord>(); 590 591 /** 592 * All of the processes that have been forced to be foreground. The key 593 * is the pid of the caller who requested it (we hold a death 594 * link on it). 595 */ 596 abstract class ForegroundToken implements IBinder.DeathRecipient { 597 int pid; 598 IBinder token; 599 } 600 final SparseArray<ForegroundToken> mForegroundProcesses = new SparseArray<ForegroundToken>(); 601 602 /** 603 * List of records for processes that someone had tried to start before the 604 * system was ready. We don't start them at that point, but ensure they 605 * are started by the time booting is complete. 606 */ 607 final ArrayList<ProcessRecord> mProcessesOnHold = new ArrayList<ProcessRecord>(); 608 609 /** 610 * List of persistent applications that are in the process 611 * of being started. 612 */ 613 final ArrayList<ProcessRecord> mPersistentStartingProcesses = new ArrayList<ProcessRecord>(); 614 615 /** 616 * Processes that are being forcibly torn down. 617 */ 618 final ArrayList<ProcessRecord> mRemovedProcesses = new ArrayList<ProcessRecord>(); 619 620 /** 621 * List of running applications, sorted by recent usage. 622 * The first entry in the list is the least recently used. 623 */ 624 final ArrayList<ProcessRecord> mLruProcesses = new ArrayList<ProcessRecord>(); 625 626 /** 627 * Where in mLruProcesses that the processes hosting activities start. 628 */ 629 int mLruProcessActivityStart = 0; 630 631 /** 632 * Where in mLruProcesses that the processes hosting services start. 633 * This is after (lower index) than mLruProcessesActivityStart. 634 */ 635 int mLruProcessServiceStart = 0; 636 637 /** 638 * List of processes that should gc as soon as things are idle. 639 */ 640 final ArrayList<ProcessRecord> mProcessesToGc = new ArrayList<ProcessRecord>(); 641 642 /** 643 * Processes we want to collect PSS data from. 644 */ 645 final ArrayList<ProcessRecord> mPendingPssProcesses = new ArrayList<ProcessRecord>(); 646 647 /** 648 * Last time we requested PSS data of all processes. 649 */ 650 long mLastFullPssTime = SystemClock.uptimeMillis(); 651 652 /** 653 * If set, the next time we collect PSS data we should do a full collection 654 * with data from native processes and the kernel. 655 */ 656 boolean mFullPssPending = false; 657 658 /** 659 * This is the process holding what we currently consider to be 660 * the "home" activity. 661 */ 662 ProcessRecord mHomeProcess; 663 664 /** 665 * This is the process holding the activity the user last visited that 666 * is in a different process from the one they are currently in. 667 */ 668 ProcessRecord mPreviousProcess; 669 670 /** 671 * The time at which the previous process was last visible. 672 */ 673 long mPreviousProcessVisibleTime; 674 675 /** 676 * Track all uids that have actively running processes. 677 */ 678 final SparseArray<UidRecord> mActiveUids = new SparseArray<>(); 679 680 /** 681 * Which users have been started, so are allowed to run code. 682 */ 683 final SparseArray<UserState> mStartedUsers = new SparseArray<>(); 684 685 /** 686 * LRU list of history of current users. Most recently current is at the end. 687 */ 688 final ArrayList<Integer> mUserLru = new ArrayList<Integer>(); 689 690 /** 691 * Constant array of the users that are currently started. 692 */ 693 int[] mStartedUserArray = new int[] { 0 }; 694 695 /** 696 * Registered observers of the user switching mechanics. 697 */ 698 final RemoteCallbackList<IUserSwitchObserver> mUserSwitchObservers 699 = new RemoteCallbackList<IUserSwitchObserver>(); 700 701 /** 702 * Currently active user switch. 703 */ 704 Object mCurUserSwitchCallback; 705 706 /** 707 * Packages that the user has asked to have run in screen size 708 * compatibility mode instead of filling the screen. 709 */ 710 final CompatModePackages mCompatModePackages; 711 712 /** 713 * Set of IntentSenderRecord objects that are currently active. 714 */ 715 final HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>> mIntentSenderRecords 716 = new HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>>(); 717 718 /** 719 * Fingerprints (hashCode()) of stack traces that we've 720 * already logged DropBox entries for. Guarded by itself. If 721 * something (rogue user app) forces this over 722 * MAX_DUP_SUPPRESSED_STACKS entries, the contents are cleared. 723 */ 724 private final HashSet<Integer> mAlreadyLoggedViolatedStacks = new HashSet<Integer>(); 725 private static final int MAX_DUP_SUPPRESSED_STACKS = 5000; 726 727 /** 728 * Strict Mode background batched logging state. 729 * 730 * The string buffer is guarded by itself, and its lock is also 731 * used to determine if another batched write is already 732 * in-flight. 733 */ 734 private final StringBuilder mStrictModeBuffer = new StringBuilder(); 735 736 /** 737 * Keeps track of all IIntentReceivers that have been registered for broadcasts. 738 * Hash keys are the receiver IBinder, hash value is a ReceiverList. 739 */ 740 final HashMap<IBinder, ReceiverList> mRegisteredReceivers = new HashMap<>(); 741 742 /** 743 * Resolver for broadcast intents to registered receivers. 744 * Holds BroadcastFilter (subclass of IntentFilter). 745 */ 746 final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver 747 = new IntentResolver<BroadcastFilter, BroadcastFilter>() { 748 @Override 749 protected boolean allowFilterResult( 750 BroadcastFilter filter, List<BroadcastFilter> dest) { 751 IBinder target = filter.receiverList.receiver.asBinder(); 752 for (int i = dest.size() - 1; i >= 0; i--) { 753 if (dest.get(i).receiverList.receiver.asBinder() == target) { 754 return false; 755 } 756 } 757 return true; 758 } 759 760 @Override 761 protected BroadcastFilter newResult(BroadcastFilter filter, int match, int userId) { 762 if (userId == UserHandle.USER_ALL || filter.owningUserId == UserHandle.USER_ALL 763 || userId == filter.owningUserId) { 764 return super.newResult(filter, match, userId); 765 } 766 return null; 767 } 768 769 @Override 770 protected BroadcastFilter[] newArray(int size) { 771 return new BroadcastFilter[size]; 772 } 773 774 @Override 775 protected boolean isPackageForFilter(String packageName, BroadcastFilter filter) { 776 return packageName.equals(filter.packageName); 777 } 778 }; 779 780 /** 781 * State of all active sticky broadcasts per user. Keys are the action of the 782 * sticky Intent, values are an ArrayList of all broadcasted intents with 783 * that action (which should usually be one). The SparseArray is keyed 784 * by the user ID the sticky is for, and can include UserHandle.USER_ALL 785 * for stickies that are sent to all users. 786 */ 787 final SparseArray<ArrayMap<String, ArrayList<Intent>>> mStickyBroadcasts = 788 new SparseArray<ArrayMap<String, ArrayList<Intent>>>(); 789 790 final ActiveServices mServices; 791 792 final static class Association { 793 final int mSourceUid; 794 final String mSourceProcess; 795 final int mTargetUid; 796 final ComponentName mTargetComponent; 797 final String mTargetProcess; 798 799 int mCount; 800 long mTime; 801 802 int mNesting; 803 long mStartTime; 804 805 Association(int sourceUid, String sourceProcess, int targetUid, 806 ComponentName targetComponent, String targetProcess) { 807 mSourceUid = sourceUid; 808 mSourceProcess = sourceProcess; 809 mTargetUid = targetUid; 810 mTargetComponent = targetComponent; 811 mTargetProcess = targetProcess; 812 } 813 } 814 815 /** 816 * When service association tracking is enabled, this is all of the associations we 817 * have seen. Mapping is target uid -> target component -> source uid -> source process name 818 * -> association data. 819 */ 820 final SparseArray<ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>>> 821 mAssociations = new SparseArray<>(); 822 boolean mTrackingAssociations; 823 824 /** 825 * Backup/restore process management 826 */ 827 String mBackupAppName = null; 828 BackupRecord mBackupTarget = null; 829 830 final ProviderMap mProviderMap; 831 832 /** 833 * List of content providers who have clients waiting for them. The 834 * application is currently being launched and the provider will be 835 * removed from this list once it is published. 836 */ 837 final ArrayList<ContentProviderRecord> mLaunchingProviders 838 = new ArrayList<ContentProviderRecord>(); 839 840 /** 841 * File storing persisted {@link #mGrantedUriPermissions}. 842 */ 843 private final AtomicFile mGrantFile; 844 845 /** XML constants used in {@link #mGrantFile} */ 846 private static final String TAG_URI_GRANTS = "uri-grants"; 847 private static final String TAG_URI_GRANT = "uri-grant"; 848 private static final String ATTR_USER_HANDLE = "userHandle"; 849 private static final String ATTR_SOURCE_USER_ID = "sourceUserId"; 850 private static final String ATTR_TARGET_USER_ID = "targetUserId"; 851 private static final String ATTR_SOURCE_PKG = "sourcePkg"; 852 private static final String ATTR_TARGET_PKG = "targetPkg"; 853 private static final String ATTR_URI = "uri"; 854 private static final String ATTR_MODE_FLAGS = "modeFlags"; 855 private static final String ATTR_CREATED_TIME = "createdTime"; 856 private static final String ATTR_PREFIX = "prefix"; 857 858 /** 859 * Global set of specific {@link Uri} permissions that have been granted. 860 * This optimized lookup structure maps from {@link UriPermission#targetUid} 861 * to {@link UriPermission#uri} to {@link UriPermission}. 862 */ 863 @GuardedBy("this") 864 private final SparseArray<ArrayMap<GrantUri, UriPermission>> 865 mGrantedUriPermissions = new SparseArray<ArrayMap<GrantUri, UriPermission>>(); 866 867 public static class GrantUri { 868 public final int sourceUserId; 869 public final Uri uri; 870 public boolean prefix; 871 872 public GrantUri(int sourceUserId, Uri uri, boolean prefix) { 873 this.sourceUserId = sourceUserId; 874 this.uri = uri; 875 this.prefix = prefix; 876 } 877 878 @Override 879 public int hashCode() { 880 int hashCode = 1; 881 hashCode = 31 * hashCode + sourceUserId; 882 hashCode = 31 * hashCode + uri.hashCode(); 883 hashCode = 31 * hashCode + (prefix ? 1231 : 1237); 884 return hashCode; 885 } 886 887 @Override 888 public boolean equals(Object o) { 889 if (o instanceof GrantUri) { 890 GrantUri other = (GrantUri) o; 891 return uri.equals(other.uri) && (sourceUserId == other.sourceUserId) 892 && prefix == other.prefix; 893 } 894 return false; 895 } 896 897 @Override 898 public String toString() { 899 String result = Integer.toString(sourceUserId) + " @ " + uri.toString(); 900 if (prefix) result += " [prefix]"; 901 return result; 902 } 903 904 public String toSafeString() { 905 String result = Integer.toString(sourceUserId) + " @ " + uri.toSafeString(); 906 if (prefix) result += " [prefix]"; 907 return result; 908 } 909 910 public static GrantUri resolve(int defaultSourceUserHandle, Uri uri) { 911 return new GrantUri(ContentProvider.getUserIdFromUri(uri, defaultSourceUserHandle), 912 ContentProvider.getUriWithoutUserId(uri), false); 913 } 914 } 915 916 CoreSettingsObserver mCoreSettingsObserver; 917 918 /** 919 * Thread-local storage used to carry caller permissions over through 920 * indirect content-provider access. 921 */ 922 private class Identity { 923 public final IBinder token; 924 public final int pid; 925 public final int uid; 926 927 Identity(IBinder _token, int _pid, int _uid) { 928 token = _token; 929 pid = _pid; 930 uid = _uid; 931 } 932 } 933 934 private static final ThreadLocal<Identity> sCallerIdentity = new ThreadLocal<Identity>(); 935 936 /** 937 * All information we have collected about the runtime performance of 938 * any user id that can impact battery performance. 939 */ 940 final BatteryStatsService mBatteryStatsService; 941 942 /** 943 * Information about component usage 944 */ 945 UsageStatsManagerInternal mUsageStatsService; 946 947 /** 948 * Access to DeviceIdleController service. 949 */ 950 DeviceIdleController.LocalService mLocalDeviceIdleController; 951 952 /** 953 * Information about and control over application operations 954 */ 955 final AppOpsService mAppOpsService; 956 957 /** 958 * Save recent tasks information across reboots. 959 */ 960 final TaskPersister mTaskPersister; 961 962 /** 963 * Current configuration information. HistoryRecord objects are given 964 * a reference to this object to indicate which configuration they are 965 * currently running in, so this object must be kept immutable. 966 */ 967 Configuration mConfiguration = new Configuration(); 968 969 /** 970 * Current sequencing integer of the configuration, for skipping old 971 * configurations. 972 */ 973 int mConfigurationSeq = 0; 974 975 /** 976 * Hardware-reported OpenGLES version. 977 */ 978 final int GL_ES_VERSION; 979 980 /** 981 * List of initialization arguments to pass to all processes when binding applications to them. 982 * For example, references to the commonly used services. 983 */ 984 HashMap<String, IBinder> mAppBindArgs; 985 986 /** 987 * Temporary to avoid allocations. Protected by main lock. 988 */ 989 final StringBuilder mStringBuilder = new StringBuilder(256); 990 991 /** 992 * Used to control how we initialize the service. 993 */ 994 ComponentName mTopComponent; 995 String mTopAction = Intent.ACTION_MAIN; 996 String mTopData; 997 boolean mProcessesReady = false; 998 boolean mSystemReady = false; 999 boolean mBooting = false; 1000 boolean mCallFinishBooting = false; 1001 boolean mBootAnimationComplete = false; 1002 boolean mWaitingUpdate = false; 1003 boolean mDidUpdate = false; 1004 boolean mOnBattery = false; 1005 boolean mLaunchWarningShown = false; 1006 1007 Context mContext; 1008 1009 int mFactoryTest; 1010 1011 boolean mCheckedForSetup; 1012 1013 /** 1014 * The time at which we will allow normal application switches again, 1015 * after a call to {@link #stopAppSwitches()}. 1016 */ 1017 long mAppSwitchesAllowedTime; 1018 1019 /** 1020 * This is set to true after the first switch after mAppSwitchesAllowedTime 1021 * is set; any switches after that will clear the time. 1022 */ 1023 boolean mDidAppSwitch; 1024 1025 /** 1026 * Last time (in realtime) at which we checked for power usage. 1027 */ 1028 long mLastPowerCheckRealtime; 1029 1030 /** 1031 * Last time (in uptime) at which we checked for power usage. 1032 */ 1033 long mLastPowerCheckUptime; 1034 1035 /** 1036 * Set while we are wanting to sleep, to prevent any 1037 * activities from being started/resumed. 1038 */ 1039 private boolean mSleeping = false; 1040 1041 /** 1042 * The process state used for processes that are running the top activities. 1043 * This changes between TOP and TOP_SLEEPING to following mSleeping. 1044 */ 1045 int mTopProcessState = ActivityManager.PROCESS_STATE_TOP; 1046 1047 /** 1048 * Set while we are running a voice interaction. This overrides 1049 * sleeping while it is active. 1050 */ 1051 private IVoiceInteractionSession mRunningVoice; 1052 1053 /** 1054 * For some direct access we need to power manager. 1055 */ 1056 PowerManagerInternal mLocalPowerManager; 1057 1058 /** 1059 * We want to hold a wake lock while running a voice interaction session, since 1060 * this may happen with the screen off and we need to keep the CPU running to 1061 * be able to continue to interact with the user. 1062 */ 1063 PowerManager.WakeLock mVoiceWakeLock; 1064 1065 /** 1066 * State of external calls telling us if the device is awake or asleep. 1067 */ 1068 private int mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE; 1069 1070 /** 1071 * A list of tokens that cause the top activity to be put to sleep. 1072 * They are used by components that may hide and block interaction with underlying 1073 * activities. 1074 */ 1075 final ArrayList<SleepToken> mSleepTokens = new ArrayList<SleepToken>(); 1076 1077 static final int LOCK_SCREEN_HIDDEN = 0; 1078 static final int LOCK_SCREEN_LEAVING = 1; 1079 static final int LOCK_SCREEN_SHOWN = 2; 1080 /** 1081 * State of external call telling us if the lock screen is shown. 1082 */ 1083 int mLockScreenShown = LOCK_SCREEN_HIDDEN; 1084 1085 /** 1086 * Set if we are shutting down the system, similar to sleeping. 1087 */ 1088 boolean mShuttingDown = false; 1089 1090 /** 1091 * Current sequence id for oom_adj computation traversal. 1092 */ 1093 int mAdjSeq = 0; 1094 1095 /** 1096 * Current sequence id for process LRU updating. 1097 */ 1098 int mLruSeq = 0; 1099 1100 /** 1101 * Keep track of the non-cached/empty process we last found, to help 1102 * determine how to distribute cached/empty processes next time. 1103 */ 1104 int mNumNonCachedProcs = 0; 1105 1106 /** 1107 * Keep track of the number of cached hidden procs, to balance oom adj 1108 * distribution between those and empty procs. 1109 */ 1110 int mNumCachedHiddenProcs = 0; 1111 1112 /** 1113 * Keep track of the number of service processes we last found, to 1114 * determine on the next iteration which should be B services. 1115 */ 1116 int mNumServiceProcs = 0; 1117 int mNewNumAServiceProcs = 0; 1118 int mNewNumServiceProcs = 0; 1119 1120 /** 1121 * Allow the current computed overall memory level of the system to go down? 1122 * This is set to false when we are killing processes for reasons other than 1123 * memory management, so that the now smaller process list will not be taken as 1124 * an indication that memory is tighter. 1125 */ 1126 boolean mAllowLowerMemLevel = false; 1127 1128 /** 1129 * The last computed memory level, for holding when we are in a state that 1130 * processes are going away for other reasons. 1131 */ 1132 int mLastMemoryLevel = ProcessStats.ADJ_MEM_FACTOR_NORMAL; 1133 1134 /** 1135 * The last total number of process we have, to determine if changes actually look 1136 * like a shrinking number of process due to lower RAM. 1137 */ 1138 int mLastNumProcesses; 1139 1140 /** 1141 * The uptime of the last time we performed idle maintenance. 1142 */ 1143 long mLastIdleTime = SystemClock.uptimeMillis(); 1144 1145 /** 1146 * Total time spent with RAM that has been added in the past since the last idle time. 1147 */ 1148 long mLowRamTimeSinceLastIdle = 0; 1149 1150 /** 1151 * If RAM is currently low, when that horrible situation started. 1152 */ 1153 long mLowRamStartTime = 0; 1154 1155 /** 1156 * For reporting to battery stats the current top application. 1157 */ 1158 private String mCurResumedPackage = null; 1159 private int mCurResumedUid = -1; 1160 1161 /** 1162 * For reporting to battery stats the apps currently running foreground 1163 * service. The ProcessMap is package/uid tuples; each of these contain 1164 * an array of the currently foreground processes. 1165 */ 1166 final ProcessMap<ArrayList<ProcessRecord>> mForegroundPackages 1167 = new ProcessMap<ArrayList<ProcessRecord>>(); 1168 1169 /** 1170 * This is set if we had to do a delayed dexopt of an app before launching 1171 * it, to increase the ANR timeouts in that case. 1172 */ 1173 boolean mDidDexOpt; 1174 1175 /** 1176 * Set if the systemServer made a call to enterSafeMode. 1177 */ 1178 boolean mSafeMode; 1179 1180 /** 1181 * If true, we are running under a test environment so will sample PSS from processes 1182 * much more rapidly to try to collect better data when the tests are rapidly 1183 * running through apps. 1184 */ 1185 boolean mTestPssMode = false; 1186 1187 String mDebugApp = null; 1188 boolean mWaitForDebugger = false; 1189 boolean mDebugTransient = false; 1190 String mOrigDebugApp = null; 1191 boolean mOrigWaitForDebugger = false; 1192 boolean mAlwaysFinishActivities = false; 1193 IActivityController mController = null; 1194 String mProfileApp = null; 1195 ProcessRecord mProfileProc = null; 1196 String mProfileFile; 1197 ParcelFileDescriptor mProfileFd; 1198 int mSamplingInterval = 0; 1199 boolean mAutoStopProfiler = false; 1200 int mProfileType = 0; 1201 String mOpenGlTraceApp = null; 1202 final ProcessMap<Pair<Long, String>> mMemWatchProcesses = new ProcessMap<>(); 1203 String mMemWatchDumpProcName; 1204 String mMemWatchDumpFile; 1205 int mMemWatchDumpPid; 1206 int mMemWatchDumpUid; 1207 String mTrackAllocationApp = null; 1208 1209 final long[] mTmpLong = new long[1]; 1210 1211 static final class ProcessChangeItem { 1212 static final int CHANGE_ACTIVITIES = 1<<0; 1213 static final int CHANGE_PROCESS_STATE = 1<<1; 1214 int changes; 1215 int uid; 1216 int pid; 1217 int processState; 1218 boolean foregroundActivities; 1219 } 1220 1221 final RemoteCallbackList<IProcessObserver> mProcessObservers = new RemoteCallbackList<>(); 1222 ProcessChangeItem[] mActiveProcessChanges = new ProcessChangeItem[5]; 1223 1224 final ArrayList<ProcessChangeItem> mPendingProcessChanges = new ArrayList<>(); 1225 final ArrayList<ProcessChangeItem> mAvailProcessChanges = new ArrayList<>(); 1226 1227 final RemoteCallbackList<IUidObserver> mUidObservers = new RemoteCallbackList<>(); 1228 UidRecord.ChangeItem[] mActiveUidChanges = new UidRecord.ChangeItem[5]; 1229 1230 final ArrayList<UidRecord.ChangeItem> mPendingUidChanges = new ArrayList<>(); 1231 final ArrayList<UidRecord.ChangeItem> mAvailUidChanges = new ArrayList<>(); 1232 1233 /** 1234 * Runtime CPU use collection thread. This object's lock is used to 1235 * perform synchronization with the thread (notifying it to run). 1236 */ 1237 final Thread mProcessCpuThread; 1238 1239 /** 1240 * Used to collect per-process CPU use for ANRs, battery stats, etc. 1241 * Must acquire this object's lock when accessing it. 1242 * NOTE: this lock will be held while doing long operations (trawling 1243 * through all processes in /proc), so it should never be acquired by 1244 * any critical paths such as when holding the main activity manager lock. 1245 */ 1246 final ProcessCpuTracker mProcessCpuTracker = new ProcessCpuTracker( 1247 MONITOR_THREAD_CPU_USAGE); 1248 final AtomicLong mLastCpuTime = new AtomicLong(0); 1249 final AtomicBoolean mProcessCpuMutexFree = new AtomicBoolean(true); 1250 1251 long mLastWriteTime = 0; 1252 1253 /** 1254 * Used to retain an update lock when the foreground activity is in 1255 * immersive mode. 1256 */ 1257 final UpdateLock mUpdateLock = new UpdateLock("immersive"); 1258 1259 /** 1260 * Set to true after the system has finished booting. 1261 */ 1262 boolean mBooted = false; 1263 1264 int mProcessLimit = ProcessList.MAX_CACHED_APPS; 1265 int mProcessLimitOverride = -1; 1266 1267 WindowManagerService mWindowManager; 1268 1269 final ActivityThread mSystemThread; 1270 1271 // Holds the current foreground user's id 1272 int mCurrentUserId = 0; 1273 // Holds the target user's id during a user switch 1274 int mTargetUserId = UserHandle.USER_NULL; 1275 // If there are multiple profiles for the current user, their ids are here 1276 // Currently only the primary user can have managed profiles 1277 int[] mCurrentProfileIds = new int[] {UserHandle.USER_OWNER}; // Accessed by ActivityStack 1278 1279 /** 1280 * Mapping from each known user ID to the profile group ID it is associated with. 1281 */ 1282 SparseIntArray mUserProfileGroupIdsSelfLocked = new SparseIntArray(); 1283 1284 private UserManagerService mUserManager; 1285 1286 private final class AppDeathRecipient implements IBinder.DeathRecipient { 1287 final ProcessRecord mApp; 1288 final int mPid; 1289 final IApplicationThread mAppThread; 1290 1291 AppDeathRecipient(ProcessRecord app, int pid, 1292 IApplicationThread thread) { 1293 if (DEBUG_ALL) Slog.v( 1294 TAG, "New death recipient " + this 1295 + " for thread " + thread.asBinder()); 1296 mApp = app; 1297 mPid = pid; 1298 mAppThread = thread; 1299 } 1300 1301 @Override 1302 public void binderDied() { 1303 if (DEBUG_ALL) Slog.v( 1304 TAG, "Death received in " + this 1305 + " for thread " + mAppThread.asBinder()); 1306 synchronized(ActivityManagerService.this) { 1307 appDiedLocked(mApp, mPid, mAppThread, true); 1308 } 1309 } 1310 } 1311 1312 static final int SHOW_ERROR_MSG = 1; 1313 static final int SHOW_NOT_RESPONDING_MSG = 2; 1314 static final int SHOW_FACTORY_ERROR_MSG = 3; 1315 static final int UPDATE_CONFIGURATION_MSG = 4; 1316 static final int GC_BACKGROUND_PROCESSES_MSG = 5; 1317 static final int WAIT_FOR_DEBUGGER_MSG = 6; 1318 static final int SERVICE_TIMEOUT_MSG = 12; 1319 static final int UPDATE_TIME_ZONE = 13; 1320 static final int SHOW_UID_ERROR_MSG = 14; 1321 static final int SHOW_FINGERPRINT_ERROR_MSG = 15; 1322 static final int PROC_START_TIMEOUT_MSG = 20; 1323 static final int DO_PENDING_ACTIVITY_LAUNCHES_MSG = 21; 1324 static final int KILL_APPLICATION_MSG = 22; 1325 static final int FINALIZE_PENDING_INTENT_MSG = 23; 1326 static final int POST_HEAVY_NOTIFICATION_MSG = 24; 1327 static final int CANCEL_HEAVY_NOTIFICATION_MSG = 25; 1328 static final int SHOW_STRICT_MODE_VIOLATION_MSG = 26; 1329 static final int CHECK_EXCESSIVE_WAKE_LOCKS_MSG = 27; 1330 static final int CLEAR_DNS_CACHE_MSG = 28; 1331 static final int UPDATE_HTTP_PROXY_MSG = 29; 1332 static final int SHOW_COMPAT_MODE_DIALOG_MSG = 30; 1333 static final int DISPATCH_PROCESSES_CHANGED = 31; 1334 static final int DISPATCH_PROCESS_DIED = 32; 1335 static final int REPORT_MEM_USAGE_MSG = 33; 1336 static final int REPORT_USER_SWITCH_MSG = 34; 1337 static final int CONTINUE_USER_SWITCH_MSG = 35; 1338 static final int USER_SWITCH_TIMEOUT_MSG = 36; 1339 static final int IMMERSIVE_MODE_LOCK_MSG = 37; 1340 static final int PERSIST_URI_GRANTS_MSG = 38; 1341 static final int REQUEST_ALL_PSS_MSG = 39; 1342 static final int START_PROFILES_MSG = 40; 1343 static final int UPDATE_TIME = 41; 1344 static final int SYSTEM_USER_START_MSG = 42; 1345 static final int SYSTEM_USER_CURRENT_MSG = 43; 1346 static final int ENTER_ANIMATION_COMPLETE_MSG = 44; 1347 static final int FINISH_BOOTING_MSG = 45; 1348 static final int START_USER_SWITCH_MSG = 46; 1349 static final int SEND_LOCALE_TO_MOUNT_DAEMON_MSG = 47; 1350 static final int DISMISS_DIALOG_MSG = 48; 1351 static final int NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG = 49; 1352 static final int NOTIFY_CLEARTEXT_NETWORK_MSG = 50; 1353 static final int POST_DUMP_HEAP_NOTIFICATION_MSG = 51; 1354 static final int DELETE_DUMPHEAP_MSG = 52; 1355 static final int FOREGROUND_PROFILE_CHANGED_MSG = 53; 1356 static final int DISPATCH_UIDS_CHANGED_MSG = 54; 1357 static final int REPORT_TIME_TRACKER_MSG = 55; 1358 static final int REPORT_USER_SWITCH_COMPLETE_MSG = 56; 1359 static final int SHUTDOWN_UI_AUTOMATION_CONNECTION_MSG = 57; 1360 1361 static final int FIRST_ACTIVITY_STACK_MSG = 100; 1362 static final int FIRST_BROADCAST_QUEUE_MSG = 200; 1363 static final int FIRST_COMPAT_MODE_MSG = 300; 1364 static final int FIRST_SUPERVISOR_STACK_MSG = 100; 1365 1366 CompatModeDialog mCompatModeDialog; 1367 long mLastMemUsageReportTime = 0; 1368 1369 /** 1370 * Flag whether the current user is a "monkey", i.e. whether 1371 * the UI is driven by a UI automation tool. 1372 */ 1373 private boolean mUserIsMonkey; 1374 1375 /** Flag whether the device has a Recents UI */ 1376 boolean mHasRecents; 1377 1378 /** The dimensions of the thumbnails in the Recents UI. */ 1379 int mThumbnailWidth; 1380 int mThumbnailHeight; 1381 1382 final ServiceThread mHandlerThread; 1383 final MainHandler mHandler; 1384 final UiHandler mUiHandler; 1385 1386 final class UiHandler extends Handler { 1387 public UiHandler() { 1388 super(com.android.server.UiThread.get().getLooper(), null, true); 1389 } 1390 1391 @Override 1392 public void handleMessage(Message msg) { 1393 switch (msg.what) { 1394 case SHOW_ERROR_MSG: { 1395 HashMap<String, Object> data = (HashMap<String, Object>) msg.obj; 1396 boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(), 1397 Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0; 1398 synchronized (ActivityManagerService.this) { 1399 ProcessRecord proc = (ProcessRecord)data.get("app"); 1400 AppErrorResult res = (AppErrorResult) data.get("result"); 1401 if (proc != null && proc.crashDialog != null) { 1402 Slog.e(TAG, "App already has crash dialog: " + proc); 1403 if (res != null) { 1404 res.set(0); 1405 } 1406 return; 1407 } 1408 boolean isBackground = (UserHandle.getAppId(proc.uid) 1409 >= Process.FIRST_APPLICATION_UID 1410 && proc.pid != MY_PID); 1411 for (int userId : mCurrentProfileIds) { 1412 isBackground &= (proc.userId != userId); 1413 } 1414 if (isBackground && !showBackground) { 1415 Slog.w(TAG, "Skipping crash dialog of " + proc + ": background"); 1416 if (res != null) { 1417 res.set(0); 1418 } 1419 return; 1420 } 1421 if (mShowDialogs && !mSleeping && !mShuttingDown) { 1422 Dialog d = new AppErrorDialog(mContext, 1423 ActivityManagerService.this, res, proc); 1424 d.show(); 1425 proc.crashDialog = d; 1426 } else { 1427 // The device is asleep, so just pretend that the user 1428 // saw a crash dialog and hit "force quit". 1429 if (res != null) { 1430 res.set(0); 1431 } 1432 } 1433 } 1434 1435 ensureBootCompleted(); 1436 } break; 1437 case SHOW_NOT_RESPONDING_MSG: { 1438 synchronized (ActivityManagerService.this) { 1439 HashMap<String, Object> data = (HashMap<String, Object>) msg.obj; 1440 ProcessRecord proc = (ProcessRecord)data.get("app"); 1441 if (proc != null && proc.anrDialog != null) { 1442 Slog.e(TAG, "App already has anr dialog: " + proc); 1443 return; 1444 } 1445 1446 Intent intent = new Intent("android.intent.action.ANR"); 1447 if (!mProcessesReady) { 1448 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 1449 | Intent.FLAG_RECEIVER_FOREGROUND); 1450 } 1451 broadcastIntentLocked(null, null, intent, 1452 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 1453 null, false, false, MY_PID, Process.SYSTEM_UID, 0 /* TODO: Verify */); 1454 1455 if (mShowDialogs) { 1456 Dialog d = new AppNotRespondingDialog(ActivityManagerService.this, 1457 mContext, proc, (ActivityRecord)data.get("activity"), 1458 msg.arg1 != 0); 1459 d.show(); 1460 proc.anrDialog = d; 1461 } else { 1462 // Just kill the app if there is no dialog to be shown. 1463 killAppAtUsersRequest(proc, null); 1464 } 1465 } 1466 1467 ensureBootCompleted(); 1468 } break; 1469 case SHOW_STRICT_MODE_VIOLATION_MSG: { 1470 HashMap<String, Object> data = (HashMap<String, Object>) msg.obj; 1471 synchronized (ActivityManagerService.this) { 1472 ProcessRecord proc = (ProcessRecord) data.get("app"); 1473 if (proc == null) { 1474 Slog.e(TAG, "App not found when showing strict mode dialog."); 1475 break; 1476 } 1477 if (proc.crashDialog != null) { 1478 Slog.e(TAG, "App already has strict mode dialog: " + proc); 1479 return; 1480 } 1481 AppErrorResult res = (AppErrorResult) data.get("result"); 1482 if (mShowDialogs && !mSleeping && !mShuttingDown) { 1483 Dialog d = new StrictModeViolationDialog(mContext, 1484 ActivityManagerService.this, res, proc); 1485 d.show(); 1486 proc.crashDialog = d; 1487 } else { 1488 // The device is asleep, so just pretend that the user 1489 // saw a crash dialog and hit "force quit". 1490 res.set(0); 1491 } 1492 } 1493 ensureBootCompleted(); 1494 } break; 1495 case SHOW_FACTORY_ERROR_MSG: { 1496 Dialog d = new FactoryErrorDialog( 1497 mContext, msg.getData().getCharSequence("msg")); 1498 d.show(); 1499 ensureBootCompleted(); 1500 } break; 1501 case WAIT_FOR_DEBUGGER_MSG: { 1502 synchronized (ActivityManagerService.this) { 1503 ProcessRecord app = (ProcessRecord)msg.obj; 1504 if (msg.arg1 != 0) { 1505 if (!app.waitedForDebugger) { 1506 Dialog d = new AppWaitingForDebuggerDialog( 1507 ActivityManagerService.this, 1508 mContext, app); 1509 app.waitDialog = d; 1510 app.waitedForDebugger = true; 1511 d.show(); 1512 } 1513 } else { 1514 if (app.waitDialog != null) { 1515 app.waitDialog.dismiss(); 1516 app.waitDialog = null; 1517 } 1518 } 1519 } 1520 } break; 1521 case SHOW_UID_ERROR_MSG: { 1522 if (mShowDialogs) { 1523 AlertDialog d = new BaseErrorDialog(mContext); 1524 d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR); 1525 d.setCancelable(false); 1526 d.setTitle(mContext.getText(R.string.android_system_label)); 1527 d.setMessage(mContext.getText(R.string.system_error_wipe_data)); 1528 d.setButton(DialogInterface.BUTTON_POSITIVE, mContext.getText(R.string.ok), 1529 obtainMessage(DISMISS_DIALOG_MSG, d)); 1530 d.show(); 1531 } 1532 } break; 1533 case SHOW_FINGERPRINT_ERROR_MSG: { 1534 if (mShowDialogs) { 1535 AlertDialog d = new BaseErrorDialog(mContext); 1536 d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR); 1537 d.setCancelable(false); 1538 d.setTitle(mContext.getText(R.string.android_system_label)); 1539 d.setMessage(mContext.getText(R.string.system_error_manufacturer)); 1540 d.setButton(DialogInterface.BUTTON_POSITIVE, mContext.getText(R.string.ok), 1541 obtainMessage(DISMISS_DIALOG_MSG, d)); 1542 d.show(); 1543 } 1544 } break; 1545 case SHOW_COMPAT_MODE_DIALOG_MSG: { 1546 synchronized (ActivityManagerService.this) { 1547 ActivityRecord ar = (ActivityRecord) msg.obj; 1548 if (mCompatModeDialog != null) { 1549 if (mCompatModeDialog.mAppInfo.packageName.equals( 1550 ar.info.applicationInfo.packageName)) { 1551 return; 1552 } 1553 mCompatModeDialog.dismiss(); 1554 mCompatModeDialog = null; 1555 } 1556 if (ar != null && false) { 1557 if (mCompatModePackages.getPackageAskCompatModeLocked( 1558 ar.packageName)) { 1559 int mode = mCompatModePackages.computeCompatModeLocked( 1560 ar.info.applicationInfo); 1561 if (mode == ActivityManager.COMPAT_MODE_DISABLED 1562 || mode == ActivityManager.COMPAT_MODE_ENABLED) { 1563 mCompatModeDialog = new CompatModeDialog( 1564 ActivityManagerService.this, mContext, 1565 ar.info.applicationInfo); 1566 mCompatModeDialog.show(); 1567 } 1568 } 1569 } 1570 } 1571 break; 1572 } 1573 case START_USER_SWITCH_MSG: { 1574 showUserSwitchDialog(msg.arg1, (String) msg.obj); 1575 break; 1576 } 1577 case DISMISS_DIALOG_MSG: { 1578 final Dialog d = (Dialog) msg.obj; 1579 d.dismiss(); 1580 break; 1581 } 1582 case DISPATCH_PROCESSES_CHANGED: { 1583 dispatchProcessesChanged(); 1584 break; 1585 } 1586 case DISPATCH_PROCESS_DIED: { 1587 final int pid = msg.arg1; 1588 final int uid = msg.arg2; 1589 dispatchProcessDied(pid, uid); 1590 break; 1591 } 1592 case DISPATCH_UIDS_CHANGED_MSG: { 1593 dispatchUidsChanged(); 1594 } break; 1595 } 1596 } 1597 } 1598 1599 final class MainHandler extends Handler { 1600 public MainHandler(Looper looper) { 1601 super(looper, null, true); 1602 } 1603 1604 @Override 1605 public void handleMessage(Message msg) { 1606 switch (msg.what) { 1607 case UPDATE_CONFIGURATION_MSG: { 1608 final ContentResolver resolver = mContext.getContentResolver(); 1609 Settings.System.putConfiguration(resolver, (Configuration) msg.obj); 1610 } break; 1611 case GC_BACKGROUND_PROCESSES_MSG: { 1612 synchronized (ActivityManagerService.this) { 1613 performAppGcsIfAppropriateLocked(); 1614 } 1615 } break; 1616 case SERVICE_TIMEOUT_MSG: { 1617 if (mDidDexOpt) { 1618 mDidDexOpt = false; 1619 Message nmsg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG); 1620 nmsg.obj = msg.obj; 1621 mHandler.sendMessageDelayed(nmsg, ActiveServices.SERVICE_TIMEOUT); 1622 return; 1623 } 1624 mServices.serviceTimeout((ProcessRecord)msg.obj); 1625 } break; 1626 case UPDATE_TIME_ZONE: { 1627 synchronized (ActivityManagerService.this) { 1628 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 1629 ProcessRecord r = mLruProcesses.get(i); 1630 if (r.thread != null) { 1631 try { 1632 r.thread.updateTimeZone(); 1633 } catch (RemoteException ex) { 1634 Slog.w(TAG, "Failed to update time zone for: " + r.info.processName); 1635 } 1636 } 1637 } 1638 } 1639 } break; 1640 case CLEAR_DNS_CACHE_MSG: { 1641 synchronized (ActivityManagerService.this) { 1642 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 1643 ProcessRecord r = mLruProcesses.get(i); 1644 if (r.thread != null) { 1645 try { 1646 r.thread.clearDnsCache(); 1647 } catch (RemoteException ex) { 1648 Slog.w(TAG, "Failed to clear dns cache for: " + r.info.processName); 1649 } 1650 } 1651 } 1652 } 1653 } break; 1654 case UPDATE_HTTP_PROXY_MSG: { 1655 ProxyInfo proxy = (ProxyInfo)msg.obj; 1656 String host = ""; 1657 String port = ""; 1658 String exclList = ""; 1659 Uri pacFileUrl = Uri.EMPTY; 1660 if (proxy != null) { 1661 host = proxy.getHost(); 1662 port = Integer.toString(proxy.getPort()); 1663 exclList = proxy.getExclusionListAsString(); 1664 pacFileUrl = proxy.getPacFileUrl(); 1665 } 1666 synchronized (ActivityManagerService.this) { 1667 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 1668 ProcessRecord r = mLruProcesses.get(i); 1669 if (r.thread != null) { 1670 try { 1671 r.thread.setHttpProxy(host, port, exclList, pacFileUrl); 1672 } catch (RemoteException ex) { 1673 Slog.w(TAG, "Failed to update http proxy for: " + 1674 r.info.processName); 1675 } 1676 } 1677 } 1678 } 1679 } break; 1680 case PROC_START_TIMEOUT_MSG: { 1681 if (mDidDexOpt) { 1682 mDidDexOpt = false; 1683 Message nmsg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG); 1684 nmsg.obj = msg.obj; 1685 mHandler.sendMessageDelayed(nmsg, PROC_START_TIMEOUT); 1686 return; 1687 } 1688 ProcessRecord app = (ProcessRecord)msg.obj; 1689 synchronized (ActivityManagerService.this) { 1690 processStartTimedOutLocked(app); 1691 } 1692 } break; 1693 case DO_PENDING_ACTIVITY_LAUNCHES_MSG: { 1694 synchronized (ActivityManagerService.this) { 1695 mStackSupervisor.doPendingActivityLaunchesLocked(true); 1696 } 1697 } break; 1698 case KILL_APPLICATION_MSG: { 1699 synchronized (ActivityManagerService.this) { 1700 int appid = msg.arg1; 1701 boolean restart = (msg.arg2 == 1); 1702 Bundle bundle = (Bundle)msg.obj; 1703 String pkg = bundle.getString("pkg"); 1704 String reason = bundle.getString("reason"); 1705 forceStopPackageLocked(pkg, appid, restart, false, true, false, 1706 false, UserHandle.USER_ALL, reason); 1707 } 1708 } break; 1709 case FINALIZE_PENDING_INTENT_MSG: { 1710 ((PendingIntentRecord)msg.obj).completeFinalize(); 1711 } break; 1712 case POST_HEAVY_NOTIFICATION_MSG: { 1713 INotificationManager inm = NotificationManager.getService(); 1714 if (inm == null) { 1715 return; 1716 } 1717 1718 ActivityRecord root = (ActivityRecord)msg.obj; 1719 ProcessRecord process = root.app; 1720 if (process == null) { 1721 return; 1722 } 1723 1724 try { 1725 Context context = mContext.createPackageContext(process.info.packageName, 0); 1726 String text = mContext.getString(R.string.heavy_weight_notification, 1727 context.getApplicationInfo().loadLabel(context.getPackageManager())); 1728 Notification notification = new Notification.Builder(context) 1729 .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb) 1730 .setWhen(0) 1731 .setOngoing(true) 1732 .setTicker(text) 1733 .setColor(mContext.getColor( 1734 com.android.internal.R.color.system_notification_accent_color)) 1735 .setContentTitle(text) 1736 .setContentText( 1737 mContext.getText(R.string.heavy_weight_notification_detail)) 1738 .setContentIntent(PendingIntent.getActivityAsUser(mContext, 0, 1739 root.intent, PendingIntent.FLAG_CANCEL_CURRENT, null, 1740 new UserHandle(root.userId))) 1741 .build(); 1742 try { 1743 int[] outId = new int[1]; 1744 inm.enqueueNotificationWithTag("android", "android", null, 1745 R.string.heavy_weight_notification, 1746 notification, outId, root.userId); 1747 } catch (RuntimeException e) { 1748 Slog.w(ActivityManagerService.TAG, 1749 "Error showing notification for heavy-weight app", e); 1750 } catch (RemoteException e) { 1751 } 1752 } catch (NameNotFoundException e) { 1753 Slog.w(TAG, "Unable to create context for heavy notification", e); 1754 } 1755 } break; 1756 case CANCEL_HEAVY_NOTIFICATION_MSG: { 1757 INotificationManager inm = NotificationManager.getService(); 1758 if (inm == null) { 1759 return; 1760 } 1761 try { 1762 inm.cancelNotificationWithTag("android", null, 1763 R.string.heavy_weight_notification, msg.arg1); 1764 } catch (RuntimeException e) { 1765 Slog.w(ActivityManagerService.TAG, 1766 "Error canceling notification for service", e); 1767 } catch (RemoteException e) { 1768 } 1769 } break; 1770 case CHECK_EXCESSIVE_WAKE_LOCKS_MSG: { 1771 synchronized (ActivityManagerService.this) { 1772 checkExcessivePowerUsageLocked(true); 1773 removeMessages(CHECK_EXCESSIVE_WAKE_LOCKS_MSG); 1774 Message nmsg = obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG); 1775 sendMessageDelayed(nmsg, POWER_CHECK_DELAY); 1776 } 1777 } break; 1778 case REPORT_MEM_USAGE_MSG: { 1779 final ArrayList<ProcessMemInfo> memInfos = (ArrayList<ProcessMemInfo>)msg.obj; 1780 Thread thread = new Thread() { 1781 @Override public void run() { 1782 reportMemUsage(memInfos); 1783 } 1784 }; 1785 thread.start(); 1786 break; 1787 } 1788 case REPORT_USER_SWITCH_MSG: { 1789 dispatchUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2); 1790 break; 1791 } 1792 case CONTINUE_USER_SWITCH_MSG: { 1793 continueUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2); 1794 break; 1795 } 1796 case USER_SWITCH_TIMEOUT_MSG: { 1797 timeoutUserSwitch((UserState) msg.obj, msg.arg1, msg.arg2); 1798 break; 1799 } 1800 case IMMERSIVE_MODE_LOCK_MSG: { 1801 final boolean nextState = (msg.arg1 != 0); 1802 if (mUpdateLock.isHeld() != nextState) { 1803 if (DEBUG_IMMERSIVE) Slog.d(TAG_IMMERSIVE, 1804 "Applying new update lock state '" + nextState 1805 + "' for " + (ActivityRecord)msg.obj); 1806 if (nextState) { 1807 mUpdateLock.acquire(); 1808 } else { 1809 mUpdateLock.release(); 1810 } 1811 } 1812 break; 1813 } 1814 case PERSIST_URI_GRANTS_MSG: { 1815 writeGrantedUriPermissions(); 1816 break; 1817 } 1818 case REQUEST_ALL_PSS_MSG: { 1819 synchronized (ActivityManagerService.this) { 1820 requestPssAllProcsLocked(SystemClock.uptimeMillis(), true, false); 1821 } 1822 break; 1823 } 1824 case START_PROFILES_MSG: { 1825 synchronized (ActivityManagerService.this) { 1826 startProfilesLocked(); 1827 } 1828 break; 1829 } 1830 case UPDATE_TIME: { 1831 synchronized (ActivityManagerService.this) { 1832 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 1833 ProcessRecord r = mLruProcesses.get(i); 1834 if (r.thread != null) { 1835 try { 1836 r.thread.updateTimePrefs(msg.arg1 == 0 ? false : true); 1837 } catch (RemoteException ex) { 1838 Slog.w(TAG, "Failed to update preferences for: " + r.info.processName); 1839 } 1840 } 1841 } 1842 } 1843 break; 1844 } 1845 case SYSTEM_USER_START_MSG: { 1846 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START, 1847 Integer.toString(msg.arg1), msg.arg1); 1848 mSystemServiceManager.startUser(msg.arg1); 1849 break; 1850 } 1851 case SYSTEM_USER_CURRENT_MSG: { 1852 mBatteryStatsService.noteEvent( 1853 BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_FINISH, 1854 Integer.toString(msg.arg2), msg.arg2); 1855 mBatteryStatsService.noteEvent( 1856 BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START, 1857 Integer.toString(msg.arg1), msg.arg1); 1858 mSystemServiceManager.switchUser(msg.arg1); 1859 break; 1860 } 1861 case ENTER_ANIMATION_COMPLETE_MSG: { 1862 synchronized (ActivityManagerService.this) { 1863 ActivityRecord r = ActivityRecord.forTokenLocked((IBinder) msg.obj); 1864 if (r != null && r.app != null && r.app.thread != null) { 1865 try { 1866 r.app.thread.scheduleEnterAnimationComplete(r.appToken); 1867 } catch (RemoteException e) { 1868 } 1869 } 1870 } 1871 break; 1872 } 1873 case FINISH_BOOTING_MSG: { 1874 if (msg.arg1 != 0) { 1875 finishBooting(); 1876 } 1877 if (msg.arg2 != 0) { 1878 enableScreenAfterBoot(); 1879 } 1880 break; 1881 } 1882 case SEND_LOCALE_TO_MOUNT_DAEMON_MSG: { 1883 try { 1884 Locale l = (Locale) msg.obj; 1885 IBinder service = ServiceManager.getService("mount"); 1886 IMountService mountService = IMountService.Stub.asInterface(service); 1887 Log.d(TAG, "Storing locale " + l.toLanguageTag() + " for decryption UI"); 1888 mountService.setField(StorageManager.SYSTEM_LOCALE_KEY, l.toLanguageTag()); 1889 } catch (RemoteException e) { 1890 Log.e(TAG, "Error storing locale for decryption UI", e); 1891 } 1892 break; 1893 } 1894 case NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG: { 1895 synchronized (ActivityManagerService.this) { 1896 int i = mTaskStackListeners.beginBroadcast(); 1897 while (i > 0) { 1898 i--; 1899 try { 1900 // Make a one-way callback to the listener 1901 mTaskStackListeners.getBroadcastItem(i).onTaskStackChanged(); 1902 } catch (RemoteException e){ 1903 // Handled by the RemoteCallbackList 1904 } 1905 } 1906 mTaskStackListeners.finishBroadcast(); 1907 } 1908 break; 1909 } 1910 case NOTIFY_CLEARTEXT_NETWORK_MSG: { 1911 final int uid = msg.arg1; 1912 final byte[] firstPacket = (byte[]) msg.obj; 1913 1914 synchronized (mPidsSelfLocked) { 1915 for (int i = 0; i < mPidsSelfLocked.size(); i++) { 1916 final ProcessRecord p = mPidsSelfLocked.valueAt(i); 1917 if (p.uid == uid) { 1918 try { 1919 p.thread.notifyCleartextNetwork(firstPacket); 1920 } catch (RemoteException ignored) { 1921 } 1922 } 1923 } 1924 } 1925 break; 1926 } 1927 case POST_DUMP_HEAP_NOTIFICATION_MSG: { 1928 final String procName; 1929 final int uid; 1930 final long memLimit; 1931 final String reportPackage; 1932 synchronized (ActivityManagerService.this) { 1933 procName = mMemWatchDumpProcName; 1934 uid = mMemWatchDumpUid; 1935 Pair<Long, String> val = mMemWatchProcesses.get(procName, uid); 1936 if (val == null) { 1937 val = mMemWatchProcesses.get(procName, 0); 1938 } 1939 if (val != null) { 1940 memLimit = val.first; 1941 reportPackage = val.second; 1942 } else { 1943 memLimit = 0; 1944 reportPackage = null; 1945 } 1946 } 1947 if (procName == null) { 1948 return; 1949 } 1950 1951 if (DEBUG_PSS) Slog.d(TAG_PSS, 1952 "Showing dump heap notification from " + procName + "/" + uid); 1953 1954 INotificationManager inm = NotificationManager.getService(); 1955 if (inm == null) { 1956 return; 1957 } 1958 1959 String text = mContext.getString(R.string.dump_heap_notification, procName); 1960 1961 1962 Intent deleteIntent = new Intent(); 1963 deleteIntent.setAction(DumpHeapActivity.ACTION_DELETE_DUMPHEAP); 1964 Intent intent = new Intent(); 1965 intent.setClassName("android", DumpHeapActivity.class.getName()); 1966 intent.putExtra(DumpHeapActivity.KEY_PROCESS, procName); 1967 intent.putExtra(DumpHeapActivity.KEY_SIZE, memLimit); 1968 if (reportPackage != null) { 1969 intent.putExtra(DumpHeapActivity.KEY_DIRECT_LAUNCH, reportPackage); 1970 } 1971 int userId = UserHandle.getUserId(uid); 1972 Notification notification = new Notification.Builder(mContext) 1973 .setSmallIcon(com.android.internal.R.drawable.stat_sys_adb) 1974 .setWhen(0) 1975 .setOngoing(true) 1976 .setAutoCancel(true) 1977 .setTicker(text) 1978 .setColor(mContext.getColor( 1979 com.android.internal.R.color.system_notification_accent_color)) 1980 .setContentTitle(text) 1981 .setContentText( 1982 mContext.getText(R.string.dump_heap_notification_detail)) 1983 .setContentIntent(PendingIntent.getActivityAsUser(mContext, 0, 1984 intent, PendingIntent.FLAG_CANCEL_CURRENT, null, 1985 new UserHandle(userId))) 1986 .setDeleteIntent(PendingIntent.getBroadcastAsUser(mContext, 0, 1987 deleteIntent, 0, UserHandle.OWNER)) 1988 .build(); 1989 1990 try { 1991 int[] outId = new int[1]; 1992 inm.enqueueNotificationWithTag("android", "android", null, 1993 R.string.dump_heap_notification, 1994 notification, outId, userId); 1995 } catch (RuntimeException e) { 1996 Slog.w(ActivityManagerService.TAG, 1997 "Error showing notification for dump heap", e); 1998 } catch (RemoteException e) { 1999 } 2000 } break; 2001 case DELETE_DUMPHEAP_MSG: { 2002 revokeUriPermission(ActivityThread.currentActivityThread().getApplicationThread(), 2003 DumpHeapActivity.JAVA_URI, 2004 Intent.FLAG_GRANT_READ_URI_PERMISSION 2005 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION, 2006 UserHandle.myUserId()); 2007 synchronized (ActivityManagerService.this) { 2008 mMemWatchDumpFile = null; 2009 mMemWatchDumpProcName = null; 2010 mMemWatchDumpPid = -1; 2011 mMemWatchDumpUid = -1; 2012 } 2013 } break; 2014 case FOREGROUND_PROFILE_CHANGED_MSG: { 2015 dispatchForegroundProfileChanged(msg.arg1); 2016 } break; 2017 case REPORT_TIME_TRACKER_MSG: { 2018 AppTimeTracker tracker = (AppTimeTracker)msg.obj; 2019 tracker.deliverResult(mContext); 2020 } break; 2021 case REPORT_USER_SWITCH_COMPLETE_MSG: { 2022 dispatchUserSwitchComplete(msg.arg1); 2023 } break; 2024 case SHUTDOWN_UI_AUTOMATION_CONNECTION_MSG: { 2025 IUiAutomationConnection connection = (IUiAutomationConnection) msg.obj; 2026 try { 2027 connection.shutdown(); 2028 } catch (RemoteException e) { 2029 Slog.w(TAG, "Error shutting down UiAutomationConnection"); 2030 } 2031 // Only a UiAutomation can set this flag and now that 2032 // it is finished we make sure it is reset to its default. 2033 mUserIsMonkey = false; 2034 } break; 2035 } 2036 } 2037 }; 2038 2039 static final int COLLECT_PSS_BG_MSG = 1; 2040 2041 final Handler mBgHandler = new Handler(BackgroundThread.getHandler().getLooper()) { 2042 @Override 2043 public void handleMessage(Message msg) { 2044 switch (msg.what) { 2045 case COLLECT_PSS_BG_MSG: { 2046 long start = SystemClock.uptimeMillis(); 2047 MemInfoReader memInfo = null; 2048 synchronized (ActivityManagerService.this) { 2049 if (mFullPssPending) { 2050 mFullPssPending = false; 2051 memInfo = new MemInfoReader(); 2052 } 2053 } 2054 if (memInfo != null) { 2055 updateCpuStatsNow(); 2056 long nativeTotalPss = 0; 2057 synchronized (mProcessCpuTracker) { 2058 final int N = mProcessCpuTracker.countStats(); 2059 for (int j=0; j<N; j++) { 2060 ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(j); 2061 if (st.vsize <= 0 || st.uid >= Process.FIRST_APPLICATION_UID) { 2062 // This is definitely an application process; skip it. 2063 continue; 2064 } 2065 synchronized (mPidsSelfLocked) { 2066 if (mPidsSelfLocked.indexOfKey(st.pid) >= 0) { 2067 // This is one of our own processes; skip it. 2068 continue; 2069 } 2070 } 2071 nativeTotalPss += Debug.getPss(st.pid, null, null); 2072 } 2073 } 2074 memInfo.readMemInfo(); 2075 synchronized (ActivityManagerService.this) { 2076 if (DEBUG_PSS) Slog.d(TAG_PSS, "Collected native and kernel memory in " 2077 + (SystemClock.uptimeMillis()-start) + "ms"); 2078 final long cachedKb = memInfo.getCachedSizeKb(); 2079 final long freeKb = memInfo.getFreeSizeKb(); 2080 final long zramKb = memInfo.getZramTotalSizeKb(); 2081 final long kernelKb = memInfo.getKernelUsedSizeKb(); 2082 EventLogTags.writeAmMeminfo(cachedKb*1024, freeKb*1024, zramKb*1024, 2083 kernelKb*1024, nativeTotalPss*1024); 2084 mProcessStats.addSysMemUsageLocked(cachedKb, freeKb, zramKb, kernelKb, 2085 nativeTotalPss); 2086 } 2087 } 2088 2089 int num = 0; 2090 long[] tmp = new long[1]; 2091 do { 2092 ProcessRecord proc; 2093 int procState; 2094 int pid; 2095 long lastPssTime; 2096 synchronized (ActivityManagerService.this) { 2097 if (mPendingPssProcesses.size() <= 0) { 2098 if (mTestPssMode || DEBUG_PSS) Slog.d(TAG_PSS, 2099 "Collected PSS of " + num + " processes in " 2100 + (SystemClock.uptimeMillis() - start) + "ms"); 2101 mPendingPssProcesses.clear(); 2102 return; 2103 } 2104 proc = mPendingPssProcesses.remove(0); 2105 procState = proc.pssProcState; 2106 lastPssTime = proc.lastPssTime; 2107 if (proc.thread != null && procState == proc.setProcState 2108 && (lastPssTime+ProcessList.PSS_SAFE_TIME_FROM_STATE_CHANGE) 2109 < SystemClock.uptimeMillis()) { 2110 pid = proc.pid; 2111 } else { 2112 proc = null; 2113 pid = 0; 2114 } 2115 } 2116 if (proc != null) { 2117 long pss = Debug.getPss(pid, tmp, null); 2118 synchronized (ActivityManagerService.this) { 2119 if (pss != 0 && proc.thread != null && proc.setProcState == procState 2120 && proc.pid == pid && proc.lastPssTime == lastPssTime) { 2121 num++; 2122 recordPssSampleLocked(proc, procState, pss, tmp[0], 2123 SystemClock.uptimeMillis()); 2124 } 2125 } 2126 } 2127 } while (true); 2128 } 2129 } 2130 } 2131 }; 2132 2133 public void setSystemProcess() { 2134 try { 2135 ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true); 2136 ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats); 2137 ServiceManager.addService("meminfo", new MemBinder(this)); 2138 ServiceManager.addService("gfxinfo", new GraphicsBinder(this)); 2139 ServiceManager.addService("dbinfo", new DbBinder(this)); 2140 if (MONITOR_CPU_USAGE) { 2141 ServiceManager.addService("cpuinfo", new CpuBinder(this)); 2142 } 2143 ServiceManager.addService("permission", new PermissionController(this)); 2144 ServiceManager.addService("processinfo", new ProcessInfoService(this)); 2145 2146 ApplicationInfo info = mContext.getPackageManager().getApplicationInfo( 2147 "android", STOCK_PM_FLAGS); 2148 mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader()); 2149 2150 synchronized (this) { 2151 ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0); 2152 app.persistent = true; 2153 app.pid = MY_PID; 2154 app.maxAdj = ProcessList.SYSTEM_ADJ; 2155 app.makeActive(mSystemThread.getApplicationThread(), mProcessStats); 2156 synchronized (mPidsSelfLocked) { 2157 mPidsSelfLocked.put(app.pid, app); 2158 } 2159 updateLruProcessLocked(app, false, null); 2160 updateOomAdjLocked(); 2161 } 2162 } catch (PackageManager.NameNotFoundException e) { 2163 throw new RuntimeException( 2164 "Unable to find android system package", e); 2165 } 2166 } 2167 2168 public void setWindowManager(WindowManagerService wm) { 2169 mWindowManager = wm; 2170 mStackSupervisor.setWindowManager(wm); 2171 } 2172 2173 public void setUsageStatsManager(UsageStatsManagerInternal usageStatsManager) { 2174 mUsageStatsService = usageStatsManager; 2175 } 2176 2177 public void startObservingNativeCrashes() { 2178 final NativeCrashListener ncl = new NativeCrashListener(this); 2179 ncl.start(); 2180 } 2181 2182 public IAppOpsService getAppOpsService() { 2183 return mAppOpsService; 2184 } 2185 2186 static class MemBinder extends Binder { 2187 ActivityManagerService mActivityManagerService; 2188 MemBinder(ActivityManagerService activityManagerService) { 2189 mActivityManagerService = activityManagerService; 2190 } 2191 2192 @Override 2193 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2194 if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP) 2195 != PackageManager.PERMISSION_GRANTED) { 2196 pw.println("Permission Denial: can't dump meminfo from from pid=" 2197 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 2198 + " without permission " + android.Manifest.permission.DUMP); 2199 return; 2200 } 2201 2202 mActivityManagerService.dumpApplicationMemoryUsage(fd, pw, " ", args, false, null); 2203 } 2204 } 2205 2206 static class GraphicsBinder extends Binder { 2207 ActivityManagerService mActivityManagerService; 2208 GraphicsBinder(ActivityManagerService activityManagerService) { 2209 mActivityManagerService = activityManagerService; 2210 } 2211 2212 @Override 2213 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2214 if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP) 2215 != PackageManager.PERMISSION_GRANTED) { 2216 pw.println("Permission Denial: can't dump gfxinfo from from pid=" 2217 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 2218 + " without permission " + android.Manifest.permission.DUMP); 2219 return; 2220 } 2221 2222 mActivityManagerService.dumpGraphicsHardwareUsage(fd, pw, args); 2223 } 2224 } 2225 2226 static class DbBinder extends Binder { 2227 ActivityManagerService mActivityManagerService; 2228 DbBinder(ActivityManagerService activityManagerService) { 2229 mActivityManagerService = activityManagerService; 2230 } 2231 2232 @Override 2233 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2234 if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP) 2235 != PackageManager.PERMISSION_GRANTED) { 2236 pw.println("Permission Denial: can't dump dbinfo from from pid=" 2237 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 2238 + " without permission " + android.Manifest.permission.DUMP); 2239 return; 2240 } 2241 2242 mActivityManagerService.dumpDbInfo(fd, pw, args); 2243 } 2244 } 2245 2246 static class CpuBinder extends Binder { 2247 ActivityManagerService mActivityManagerService; 2248 CpuBinder(ActivityManagerService activityManagerService) { 2249 mActivityManagerService = activityManagerService; 2250 } 2251 2252 @Override 2253 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 2254 if (mActivityManagerService.checkCallingPermission(android.Manifest.permission.DUMP) 2255 != PackageManager.PERMISSION_GRANTED) { 2256 pw.println("Permission Denial: can't dump cpuinfo from from pid=" 2257 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 2258 + " without permission " + android.Manifest.permission.DUMP); 2259 return; 2260 } 2261 2262 synchronized (mActivityManagerService.mProcessCpuTracker) { 2263 pw.print(mActivityManagerService.mProcessCpuTracker.printCurrentLoad()); 2264 pw.print(mActivityManagerService.mProcessCpuTracker.printCurrentState( 2265 SystemClock.uptimeMillis())); 2266 } 2267 } 2268 } 2269 2270 public static final class Lifecycle extends SystemService { 2271 private final ActivityManagerService mService; 2272 2273 public Lifecycle(Context context) { 2274 super(context); 2275 mService = new ActivityManagerService(context); 2276 } 2277 2278 @Override 2279 public void onStart() { 2280 mService.start(); 2281 } 2282 2283 public ActivityManagerService getService() { 2284 return mService; 2285 } 2286 } 2287 2288 // Note: This method is invoked on the main thread but may need to attach various 2289 // handlers to other threads. So take care to be explicit about the looper. 2290 public ActivityManagerService(Context systemContext) { 2291 mContext = systemContext; 2292 mFactoryTest = FactoryTest.getMode(); 2293 mSystemThread = ActivityThread.currentActivityThread(); 2294 2295 Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass()); 2296 2297 mHandlerThread = new ServiceThread(TAG, 2298 android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/); 2299 mHandlerThread.start(); 2300 mHandler = new MainHandler(mHandlerThread.getLooper()); 2301 mUiHandler = new UiHandler(); 2302 2303 mFgBroadcastQueue = new BroadcastQueue(this, mHandler, 2304 "foreground", BROADCAST_FG_TIMEOUT, false); 2305 mBgBroadcastQueue = new BroadcastQueue(this, mHandler, 2306 "background", BROADCAST_BG_TIMEOUT, true); 2307 mBroadcastQueues[0] = mFgBroadcastQueue; 2308 mBroadcastQueues[1] = mBgBroadcastQueue; 2309 2310 mServices = new ActiveServices(this); 2311 mProviderMap = new ProviderMap(this); 2312 2313 // TODO: Move creation of battery stats service outside of activity manager service. 2314 File dataDir = Environment.getDataDirectory(); 2315 File systemDir = new File(dataDir, "system"); 2316 systemDir.mkdirs(); 2317 mBatteryStatsService = new BatteryStatsService(systemDir, mHandler); 2318 mBatteryStatsService.getActiveStatistics().readLocked(); 2319 mBatteryStatsService.scheduleWriteToDisk(); 2320 mOnBattery = DEBUG_POWER ? true 2321 : mBatteryStatsService.getActiveStatistics().getIsOnBattery(); 2322 mBatteryStatsService.getActiveStatistics().setCallback(this); 2323 2324 mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats")); 2325 2326 mAppOpsService = new AppOpsService(new File(systemDir, "appops.xml"), mHandler); 2327 2328 mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml")); 2329 2330 // User 0 is the first and only user that runs at boot. 2331 mStartedUsers.put(UserHandle.USER_OWNER, new UserState(UserHandle.OWNER, true)); 2332 mUserLru.add(UserHandle.USER_OWNER); 2333 updateStartedUserArrayLocked(); 2334 2335 GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", 2336 ConfigurationInfo.GL_ES_VERSION_UNDEFINED); 2337 2338 mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations")); 2339 2340 mConfiguration.setToDefaults(); 2341 mConfiguration.setLocale(Locale.getDefault()); 2342 2343 mConfigurationSeq = mConfiguration.seq = 1; 2344 mProcessCpuTracker.init(); 2345 2346 mCompatModePackages = new CompatModePackages(this, systemDir, mHandler); 2347 mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler); 2348 mRecentTasks = new RecentTasks(this); 2349 mStackSupervisor = new ActivityStackSupervisor(this, mRecentTasks); 2350 mTaskPersister = new TaskPersister(systemDir, mStackSupervisor, mRecentTasks); 2351 2352 mProcessCpuThread = new Thread("CpuTracker") { 2353 @Override 2354 public void run() { 2355 while (true) { 2356 try { 2357 try { 2358 synchronized(this) { 2359 final long now = SystemClock.uptimeMillis(); 2360 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now; 2361 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now; 2362 //Slog.i(TAG, "Cpu delay=" + nextCpuDelay 2363 // + ", write delay=" + nextWriteDelay); 2364 if (nextWriteDelay < nextCpuDelay) { 2365 nextCpuDelay = nextWriteDelay; 2366 } 2367 if (nextCpuDelay > 0) { 2368 mProcessCpuMutexFree.set(true); 2369 this.wait(nextCpuDelay); 2370 } 2371 } 2372 } catch (InterruptedException e) { 2373 } 2374 updateCpuStatsNow(); 2375 } catch (Exception e) { 2376 Slog.e(TAG, "Unexpected exception collecting process stats", e); 2377 } 2378 } 2379 } 2380 }; 2381 2382 Watchdog.getInstance().addMonitor(this); 2383 Watchdog.getInstance().addThread(mHandler); 2384 } 2385 2386 public void setSystemServiceManager(SystemServiceManager mgr) { 2387 mSystemServiceManager = mgr; 2388 } 2389 2390 public void setInstaller(Installer installer) { 2391 mInstaller = installer; 2392 } 2393 2394 private void start() { 2395 Process.removeAllProcessGroups(); 2396 mProcessCpuThread.start(); 2397 2398 mBatteryStatsService.publish(mContext); 2399 mAppOpsService.publish(mContext); 2400 Slog.d("AppOps", "AppOpsService published"); 2401 LocalServices.addService(ActivityManagerInternal.class, new LocalService()); 2402 } 2403 2404 public void initPowerManagement() { 2405 mStackSupervisor.initPowerManagement(); 2406 mBatteryStatsService.initPowerManagement(); 2407 mLocalPowerManager = LocalServices.getService(PowerManagerInternal.class); 2408 PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE); 2409 mVoiceWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*voice*"); 2410 mVoiceWakeLock.setReferenceCounted(false); 2411 } 2412 2413 @Override 2414 public boolean onTransact(int code, Parcel data, Parcel reply, int flags) 2415 throws RemoteException { 2416 if (code == SYSPROPS_TRANSACTION) { 2417 // We need to tell all apps about the system property change. 2418 ArrayList<IBinder> procs = new ArrayList<IBinder>(); 2419 synchronized(this) { 2420 final int NP = mProcessNames.getMap().size(); 2421 for (int ip=0; ip<NP; ip++) { 2422 SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip); 2423 final int NA = apps.size(); 2424 for (int ia=0; ia<NA; ia++) { 2425 ProcessRecord app = apps.valueAt(ia); 2426 if (app.thread != null) { 2427 procs.add(app.thread.asBinder()); 2428 } 2429 } 2430 } 2431 } 2432 2433 int N = procs.size(); 2434 for (int i=0; i<N; i++) { 2435 Parcel data2 = Parcel.obtain(); 2436 try { 2437 procs.get(i).transact(IBinder.SYSPROPS_TRANSACTION, data2, null, 0); 2438 } catch (RemoteException e) { 2439 } 2440 data2.recycle(); 2441 } 2442 } 2443 try { 2444 return super.onTransact(code, data, reply, flags); 2445 } catch (RuntimeException e) { 2446 // The activity manager only throws security exceptions, so let's 2447 // log all others. 2448 if (!(e instanceof SecurityException)) { 2449 Slog.wtf(TAG, "Activity Manager Crash", e); 2450 } 2451 throw e; 2452 } 2453 } 2454 2455 void updateCpuStats() { 2456 final long now = SystemClock.uptimeMillis(); 2457 if (mLastCpuTime.get() >= now - MONITOR_CPU_MIN_TIME) { 2458 return; 2459 } 2460 if (mProcessCpuMutexFree.compareAndSet(true, false)) { 2461 synchronized (mProcessCpuThread) { 2462 mProcessCpuThread.notify(); 2463 } 2464 } 2465 } 2466 2467 void updateCpuStatsNow() { 2468 synchronized (mProcessCpuTracker) { 2469 mProcessCpuMutexFree.set(false); 2470 final long now = SystemClock.uptimeMillis(); 2471 boolean haveNewCpuStats = false; 2472 2473 if (MONITOR_CPU_USAGE && 2474 mLastCpuTime.get() < (now-MONITOR_CPU_MIN_TIME)) { 2475 mLastCpuTime.set(now); 2476 mProcessCpuTracker.update(); 2477 if (mProcessCpuTracker.hasGoodLastStats()) { 2478 haveNewCpuStats = true; 2479 //Slog.i(TAG, mProcessCpu.printCurrentState()); 2480 //Slog.i(TAG, "Total CPU usage: " 2481 // + mProcessCpu.getTotalCpuPercent() + "%"); 2482 2483 // Slog the cpu usage if the property is set. 2484 if ("true".equals(SystemProperties.get("events.cpu"))) { 2485 int user = mProcessCpuTracker.getLastUserTime(); 2486 int system = mProcessCpuTracker.getLastSystemTime(); 2487 int iowait = mProcessCpuTracker.getLastIoWaitTime(); 2488 int irq = mProcessCpuTracker.getLastIrqTime(); 2489 int softIrq = mProcessCpuTracker.getLastSoftIrqTime(); 2490 int idle = mProcessCpuTracker.getLastIdleTime(); 2491 2492 int total = user + system + iowait + irq + softIrq + idle; 2493 if (total == 0) total = 1; 2494 2495 EventLog.writeEvent(EventLogTags.CPU, 2496 ((user+system+iowait+irq+softIrq) * 100) / total, 2497 (user * 100) / total, 2498 (system * 100) / total, 2499 (iowait * 100) / total, 2500 (irq * 100) / total, 2501 (softIrq * 100) / total); 2502 } 2503 } 2504 } 2505 2506 final BatteryStatsImpl bstats = mBatteryStatsService.getActiveStatistics(); 2507 synchronized(bstats) { 2508 synchronized(mPidsSelfLocked) { 2509 if (haveNewCpuStats) { 2510 if (bstats.startAddingCpuLocked()) { 2511 int totalUTime = 0; 2512 int totalSTime = 0; 2513 final int N = mProcessCpuTracker.countStats(); 2514 for (int i=0; i<N; i++) { 2515 ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i); 2516 if (!st.working) { 2517 continue; 2518 } 2519 ProcessRecord pr = mPidsSelfLocked.get(st.pid); 2520 totalUTime += st.rel_utime; 2521 totalSTime += st.rel_stime; 2522 if (pr != null) { 2523 BatteryStatsImpl.Uid.Proc ps = pr.curProcBatteryStats; 2524 if (ps == null || !ps.isActive()) { 2525 pr.curProcBatteryStats = ps = bstats.getProcessStatsLocked( 2526 pr.info.uid, pr.processName); 2527 } 2528 ps.addCpuTimeLocked(st.rel_utime, st.rel_stime); 2529 pr.curCpuTime += st.rel_utime + st.rel_stime; 2530 } else { 2531 BatteryStatsImpl.Uid.Proc ps = st.batteryStats; 2532 if (ps == null || !ps.isActive()) { 2533 st.batteryStats = ps = bstats.getProcessStatsLocked( 2534 bstats.mapUid(st.uid), st.name); 2535 } 2536 ps.addCpuTimeLocked(st.rel_utime, st.rel_stime); 2537 } 2538 } 2539 final int userTime = mProcessCpuTracker.getLastUserTime(); 2540 final int systemTime = mProcessCpuTracker.getLastSystemTime(); 2541 final int iowaitTime = mProcessCpuTracker.getLastIoWaitTime(); 2542 final int irqTime = mProcessCpuTracker.getLastIrqTime(); 2543 final int softIrqTime = mProcessCpuTracker.getLastSoftIrqTime(); 2544 final int idleTime = mProcessCpuTracker.getLastIdleTime(); 2545 bstats.finishAddingCpuLocked(totalUTime, totalSTime, userTime, 2546 systemTime, iowaitTime, irqTime, softIrqTime, idleTime); 2547 } 2548 } 2549 } 2550 2551 if (mLastWriteTime < (now-BATTERY_STATS_TIME)) { 2552 mLastWriteTime = now; 2553 mBatteryStatsService.scheduleWriteToDisk(); 2554 } 2555 } 2556 } 2557 } 2558 2559 @Override 2560 public void batteryNeedsCpuUpdate() { 2561 updateCpuStatsNow(); 2562 } 2563 2564 @Override 2565 public void batteryPowerChanged(boolean onBattery) { 2566 // When plugging in, update the CPU stats first before changing 2567 // the plug state. 2568 updateCpuStatsNow(); 2569 synchronized (this) { 2570 synchronized(mPidsSelfLocked) { 2571 mOnBattery = DEBUG_POWER ? true : onBattery; 2572 } 2573 } 2574 } 2575 2576 @Override 2577 public void batterySendBroadcast(Intent intent) { 2578 broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, 2579 AppOpsManager.OP_NONE, null, false, false, 2580 -1, Process.SYSTEM_UID, UserHandle.USER_ALL); 2581 } 2582 2583 /** 2584 * Initialize the application bind args. These are passed to each 2585 * process when the bindApplication() IPC is sent to the process. They're 2586 * lazily setup to make sure the services are running when they're asked for. 2587 */ 2588 private HashMap<String, IBinder> getCommonServicesLocked(boolean isolated) { 2589 if (mAppBindArgs == null) { 2590 mAppBindArgs = new HashMap<>(); 2591 2592 // Isolated processes won't get this optimization, so that we don't 2593 // violate the rules about which services they have access to. 2594 if (!isolated) { 2595 // Setup the application init args 2596 mAppBindArgs.put("package", ServiceManager.getService("package")); 2597 mAppBindArgs.put("window", ServiceManager.getService("window")); 2598 mAppBindArgs.put(Context.ALARM_SERVICE, 2599 ServiceManager.getService(Context.ALARM_SERVICE)); 2600 } 2601 } 2602 return mAppBindArgs; 2603 } 2604 2605 final void setFocusedActivityLocked(ActivityRecord r, String reason) { 2606 if (r != null && mFocusedActivity != r) { 2607 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedActivityLocked: r=" + r); 2608 ActivityRecord last = mFocusedActivity; 2609 mFocusedActivity = r; 2610 if (r.task.taskType != ActivityRecord.HOME_ACTIVITY_TYPE 2611 && r.task.taskType != ActivityRecord.RECENTS_ACTIVITY_TYPE) { 2612 if (mCurAppTimeTracker != r.appTimeTracker) { 2613 // We are switching app tracking. Complete the current one. 2614 if (mCurAppTimeTracker != null) { 2615 mCurAppTimeTracker.stop(); 2616 mHandler.obtainMessage(REPORT_TIME_TRACKER_MSG, 2617 mCurAppTimeTracker).sendToTarget(); 2618 mStackSupervisor.clearOtherAppTimeTrackers(r.appTimeTracker); 2619 mCurAppTimeTracker = null; 2620 } 2621 if (r.appTimeTracker != null) { 2622 mCurAppTimeTracker = r.appTimeTracker; 2623 startTimeTrackingFocusedActivityLocked(); 2624 } 2625 } else { 2626 startTimeTrackingFocusedActivityLocked(); 2627 } 2628 } else { 2629 r.appTimeTracker = null; 2630 } 2631 if (r.task != null && r.task.voiceInteractor != null) { 2632 startRunningVoiceLocked(r.task.voiceSession, r.info.applicationInfo.uid); 2633 } else { 2634 finishRunningVoiceLocked(); 2635 if (last != null && last.task.voiceSession != null) { 2636 // We had been in a voice interaction session, but now focused has 2637 // move to something different. Just finish the session, we can't 2638 // return to it and retain the proper state and synchronization with 2639 // the voice interaction service. 2640 finishVoiceTask(last.task.voiceSession); 2641 } 2642 } 2643 if (mStackSupervisor.setFocusedStack(r, reason + " setFocusedActivity")) { 2644 mWindowManager.setFocusedApp(r.appToken, true); 2645 } 2646 applyUpdateLockStateLocked(r); 2647 if (mFocusedActivity.userId != mLastFocusedUserId) { 2648 mHandler.removeMessages(FOREGROUND_PROFILE_CHANGED_MSG); 2649 mHandler.sendMessage(mHandler.obtainMessage(FOREGROUND_PROFILE_CHANGED_MSG, 2650 mFocusedActivity.userId, 0)); 2651 mLastFocusedUserId = mFocusedActivity.userId; 2652 } 2653 } 2654 EventLog.writeEvent(EventLogTags.AM_FOCUSED_ACTIVITY, 2655 mFocusedActivity == null ? -1 : mFocusedActivity.userId, 2656 mFocusedActivity == null ? "NULL" : mFocusedActivity.shortComponentName); 2657 } 2658 2659 final void clearFocusedActivity(ActivityRecord r) { 2660 if (mFocusedActivity == r) { 2661 ActivityStack stack = mStackSupervisor.getFocusedStack(); 2662 if (stack != null) { 2663 ActivityRecord top = stack.topActivity(); 2664 if (top != null && top.userId != mLastFocusedUserId) { 2665 mHandler.removeMessages(FOREGROUND_PROFILE_CHANGED_MSG); 2666 mHandler.sendMessage(mHandler.obtainMessage(FOREGROUND_PROFILE_CHANGED_MSG, 2667 top.userId, 0)); 2668 mLastFocusedUserId = top.userId; 2669 } 2670 } 2671 mFocusedActivity = null; 2672 EventLog.writeEvent(EventLogTags.AM_FOCUSED_ACTIVITY, -1, "NULL"); 2673 } 2674 } 2675 2676 @Override 2677 public void setFocusedStack(int stackId) { 2678 if (DEBUG_FOCUS) Slog.d(TAG_FOCUS, "setFocusedStack: stackId=" + stackId); 2679 synchronized (ActivityManagerService.this) { 2680 ActivityStack stack = mStackSupervisor.getStack(stackId); 2681 if (stack != null) { 2682 ActivityRecord r = stack.topRunningActivityLocked(null); 2683 if (r != null) { 2684 setFocusedActivityLocked(r, "setFocusedStack"); 2685 mStackSupervisor.resumeTopActivitiesLocked(stack, null, null); 2686 } 2687 } 2688 } 2689 } 2690 2691 /** Sets the task stack listener that gets callbacks when a task stack changes. */ 2692 @Override 2693 public void registerTaskStackListener(ITaskStackListener listener) throws RemoteException { 2694 synchronized (ActivityManagerService.this) { 2695 if (listener != null) { 2696 mTaskStackListeners.register(listener); 2697 } 2698 } 2699 } 2700 2701 @Override 2702 public void notifyActivityDrawn(IBinder token) { 2703 if (DEBUG_VISIBILITY) Slog.d(TAG_VISIBILITY, "notifyActivityDrawn: token=" + token); 2704 synchronized (this) { 2705 ActivityRecord r = mStackSupervisor.isInAnyStackLocked(token); 2706 if (r != null) { 2707 r.task.stack.notifyActivityDrawnLocked(r); 2708 } 2709 } 2710 } 2711 2712 final void applyUpdateLockStateLocked(ActivityRecord r) { 2713 // Modifications to the UpdateLock state are done on our handler, outside 2714 // the activity manager's locks. The new state is determined based on the 2715 // state *now* of the relevant activity record. The object is passed to 2716 // the handler solely for logging detail, not to be consulted/modified. 2717 final boolean nextState = r != null && r.immersive; 2718 mHandler.sendMessage( 2719 mHandler.obtainMessage(IMMERSIVE_MODE_LOCK_MSG, (nextState) ? 1 : 0, 0, r)); 2720 } 2721 2722 final void showAskCompatModeDialogLocked(ActivityRecord r) { 2723 Message msg = Message.obtain(); 2724 msg.what = SHOW_COMPAT_MODE_DIALOG_MSG; 2725 msg.obj = r.task.askedCompatMode ? null : r; 2726 mUiHandler.sendMessage(msg); 2727 } 2728 2729 private int updateLruProcessInternalLocked(ProcessRecord app, long now, int index, 2730 String what, Object obj, ProcessRecord srcApp) { 2731 app.lastActivityTime = now; 2732 2733 if (app.activities.size() > 0) { 2734 // Don't want to touch dependent processes that are hosting activities. 2735 return index; 2736 } 2737 2738 int lrui = mLruProcesses.lastIndexOf(app); 2739 if (lrui < 0) { 2740 Slog.wtf(TAG, "Adding dependent process " + app + " not on LRU list: " 2741 + what + " " + obj + " from " + srcApp); 2742 return index; 2743 } 2744 2745 if (lrui >= index) { 2746 // Don't want to cause this to move dependent processes *back* in the 2747 // list as if they were less frequently used. 2748 return index; 2749 } 2750 2751 if (lrui >= mLruProcessActivityStart) { 2752 // Don't want to touch dependent processes that are hosting activities. 2753 return index; 2754 } 2755 2756 mLruProcesses.remove(lrui); 2757 if (index > 0) { 2758 index--; 2759 } 2760 if (DEBUG_LRU) Slog.d(TAG_LRU, "Moving dep from " + lrui + " to " + index 2761 + " in LRU list: " + app); 2762 mLruProcesses.add(index, app); 2763 return index; 2764 } 2765 2766 private static void killProcessGroup(int uid, int pid) { 2767 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "killProcessGroup"); 2768 Process.killProcessGroup(uid, pid); 2769 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 2770 } 2771 2772 final void removeLruProcessLocked(ProcessRecord app) { 2773 int lrui = mLruProcesses.lastIndexOf(app); 2774 if (lrui >= 0) { 2775 if (!app.killed) { 2776 Slog.wtfStack(TAG, "Removing process that hasn't been killed: " + app); 2777 Process.killProcessQuiet(app.pid); 2778 killProcessGroup(app.info.uid, app.pid); 2779 } 2780 if (lrui <= mLruProcessActivityStart) { 2781 mLruProcessActivityStart--; 2782 } 2783 if (lrui <= mLruProcessServiceStart) { 2784 mLruProcessServiceStart--; 2785 } 2786 mLruProcesses.remove(lrui); 2787 } 2788 } 2789 2790 final void updateLruProcessLocked(ProcessRecord app, boolean activityChange, 2791 ProcessRecord client) { 2792 final boolean hasActivity = app.activities.size() > 0 || app.hasClientActivities 2793 || app.treatLikeActivity; 2794 final boolean hasService = false; // not impl yet. app.services.size() > 0; 2795 if (!activityChange && hasActivity) { 2796 // The process has activities, so we are only allowing activity-based adjustments 2797 // to move it. It should be kept in the front of the list with other 2798 // processes that have activities, and we don't want those to change their 2799 // order except due to activity operations. 2800 return; 2801 } 2802 2803 mLruSeq++; 2804 final long now = SystemClock.uptimeMillis(); 2805 app.lastActivityTime = now; 2806 2807 // First a quick reject: if the app is already at the position we will 2808 // put it, then there is nothing to do. 2809 if (hasActivity) { 2810 final int N = mLruProcesses.size(); 2811 if (N > 0 && mLruProcesses.get(N-1) == app) { 2812 if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, already top activity: " + app); 2813 return; 2814 } 2815 } else { 2816 if (mLruProcessServiceStart > 0 2817 && mLruProcesses.get(mLruProcessServiceStart-1) == app) { 2818 if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, already top other: " + app); 2819 return; 2820 } 2821 } 2822 2823 int lrui = mLruProcesses.lastIndexOf(app); 2824 2825 if (app.persistent && lrui >= 0) { 2826 // We don't care about the position of persistent processes, as long as 2827 // they are in the list. 2828 if (DEBUG_LRU) Slog.d(TAG_LRU, "Not moving, persistent: " + app); 2829 return; 2830 } 2831 2832 /* In progress: compute new position first, so we can avoid doing work 2833 if the process is not actually going to move. Not yet working. 2834 int addIndex; 2835 int nextIndex; 2836 boolean inActivity = false, inService = false; 2837 if (hasActivity) { 2838 // Process has activities, put it at the very tipsy-top. 2839 addIndex = mLruProcesses.size(); 2840 nextIndex = mLruProcessServiceStart; 2841 inActivity = true; 2842 } else if (hasService) { 2843 // Process has services, put it at the top of the service list. 2844 addIndex = mLruProcessActivityStart; 2845 nextIndex = mLruProcessServiceStart; 2846 inActivity = true; 2847 inService = true; 2848 } else { 2849 // Process not otherwise of interest, it goes to the top of the non-service area. 2850 addIndex = mLruProcessServiceStart; 2851 if (client != null) { 2852 int clientIndex = mLruProcesses.lastIndexOf(client); 2853 if (clientIndex < 0) Slog.d(TAG, "Unknown client " + client + " when updating " 2854 + app); 2855 if (clientIndex >= 0 && addIndex > clientIndex) { 2856 addIndex = clientIndex; 2857 } 2858 } 2859 nextIndex = addIndex > 0 ? addIndex-1 : addIndex; 2860 } 2861 2862 Slog.d(TAG, "Update LRU at " + lrui + " to " + addIndex + " (act=" 2863 + mLruProcessActivityStart + "): " + app); 2864 */ 2865 2866 if (lrui >= 0) { 2867 if (lrui < mLruProcessActivityStart) { 2868 mLruProcessActivityStart--; 2869 } 2870 if (lrui < mLruProcessServiceStart) { 2871 mLruProcessServiceStart--; 2872 } 2873 /* 2874 if (addIndex > lrui) { 2875 addIndex--; 2876 } 2877 if (nextIndex > lrui) { 2878 nextIndex--; 2879 } 2880 */ 2881 mLruProcesses.remove(lrui); 2882 } 2883 2884 /* 2885 mLruProcesses.add(addIndex, app); 2886 if (inActivity) { 2887 mLruProcessActivityStart++; 2888 } 2889 if (inService) { 2890 mLruProcessActivityStart++; 2891 } 2892 */ 2893 2894 int nextIndex; 2895 if (hasActivity) { 2896 final int N = mLruProcesses.size(); 2897 if (app.activities.size() == 0 && mLruProcessActivityStart < (N - 1)) { 2898 // Process doesn't have activities, but has clients with 2899 // activities... move it up, but one below the top (the top 2900 // should always have a real activity). 2901 if (DEBUG_LRU) Slog.d(TAG_LRU, 2902 "Adding to second-top of LRU activity list: " + app); 2903 mLruProcesses.add(N - 1, app); 2904 // To keep it from spamming the LRU list (by making a bunch of clients), 2905 // we will push down any other entries owned by the app. 2906 final int uid = app.info.uid; 2907 for (int i = N - 2; i > mLruProcessActivityStart; i--) { 2908 ProcessRecord subProc = mLruProcesses.get(i); 2909 if (subProc.info.uid == uid) { 2910 // We want to push this one down the list. If the process after 2911 // it is for the same uid, however, don't do so, because we don't 2912 // want them internally to be re-ordered. 2913 if (mLruProcesses.get(i - 1).info.uid != uid) { 2914 if (DEBUG_LRU) Slog.d(TAG_LRU, 2915 "Pushing uid " + uid + " swapping at " + i + ": " 2916 + mLruProcesses.get(i) + " : " + mLruProcesses.get(i - 1)); 2917 ProcessRecord tmp = mLruProcesses.get(i); 2918 mLruProcesses.set(i, mLruProcesses.get(i - 1)); 2919 mLruProcesses.set(i - 1, tmp); 2920 i--; 2921 } 2922 } else { 2923 // A gap, we can stop here. 2924 break; 2925 } 2926 } 2927 } else { 2928 // Process has activities, put it at the very tipsy-top. 2929 if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding to top of LRU activity list: " + app); 2930 mLruProcesses.add(app); 2931 } 2932 nextIndex = mLruProcessServiceStart; 2933 } else if (hasService) { 2934 // Process has services, put it at the top of the service list. 2935 if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding to top of LRU service list: " + app); 2936 mLruProcesses.add(mLruProcessActivityStart, app); 2937 nextIndex = mLruProcessServiceStart; 2938 mLruProcessActivityStart++; 2939 } else { 2940 // Process not otherwise of interest, it goes to the top of the non-service area. 2941 int index = mLruProcessServiceStart; 2942 if (client != null) { 2943 // If there is a client, don't allow the process to be moved up higher 2944 // in the list than that client. 2945 int clientIndex = mLruProcesses.lastIndexOf(client); 2946 if (DEBUG_LRU && clientIndex < 0) Slog.d(TAG_LRU, "Unknown client " + client 2947 + " when updating " + app); 2948 if (clientIndex <= lrui) { 2949 // Don't allow the client index restriction to push it down farther in the 2950 // list than it already is. 2951 clientIndex = lrui; 2952 } 2953 if (clientIndex >= 0 && index > clientIndex) { 2954 index = clientIndex; 2955 } 2956 } 2957 if (DEBUG_LRU) Slog.d(TAG_LRU, "Adding at " + index + " of LRU list: " + app); 2958 mLruProcesses.add(index, app); 2959 nextIndex = index-1; 2960 mLruProcessActivityStart++; 2961 mLruProcessServiceStart++; 2962 } 2963 2964 // If the app is currently using a content provider or service, 2965 // bump those processes as well. 2966 for (int j=app.connections.size()-1; j>=0; j--) { 2967 ConnectionRecord cr = app.connections.valueAt(j); 2968 if (cr.binding != null && !cr.serviceDead && cr.binding.service != null 2969 && cr.binding.service.app != null 2970 && cr.binding.service.app.lruSeq != mLruSeq 2971 && !cr.binding.service.app.persistent) { 2972 nextIndex = updateLruProcessInternalLocked(cr.binding.service.app, now, nextIndex, 2973 "service connection", cr, app); 2974 } 2975 } 2976 for (int j=app.conProviders.size()-1; j>=0; j--) { 2977 ContentProviderRecord cpr = app.conProviders.get(j).provider; 2978 if (cpr.proc != null && cpr.proc.lruSeq != mLruSeq && !cpr.proc.persistent) { 2979 nextIndex = updateLruProcessInternalLocked(cpr.proc, now, nextIndex, 2980 "provider reference", cpr, app); 2981 } 2982 } 2983 } 2984 2985 final ProcessRecord getProcessRecordLocked(String processName, int uid, boolean keepIfLarge) { 2986 if (uid == Process.SYSTEM_UID) { 2987 // The system gets to run in any process. If there are multiple 2988 // processes with the same uid, just pick the first (this 2989 // should never happen). 2990 SparseArray<ProcessRecord> procs = mProcessNames.getMap().get(processName); 2991 if (procs == null) return null; 2992 final int procCount = procs.size(); 2993 for (int i = 0; i < procCount; i++) { 2994 final int procUid = procs.keyAt(i); 2995 if (UserHandle.isApp(procUid) || !UserHandle.isSameUser(procUid, uid)) { 2996 // Don't use an app process or different user process for system component. 2997 continue; 2998 } 2999 return procs.valueAt(i); 3000 } 3001 } 3002 ProcessRecord proc = mProcessNames.get(processName, uid); 3003 if (false && proc != null && !keepIfLarge 3004 && proc.setProcState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY 3005 && proc.lastCachedPss >= 4000) { 3006 // Turn this condition on to cause killing to happen regularly, for testing. 3007 if (proc.baseProcessTracker != null) { 3008 proc.baseProcessTracker.reportCachedKill(proc.pkgList, proc.lastCachedPss); 3009 } 3010 proc.kill(Long.toString(proc.lastCachedPss) + "k from cached", true); 3011 } else if (proc != null && !keepIfLarge 3012 && mLastMemoryLevel > ProcessStats.ADJ_MEM_FACTOR_NORMAL 3013 && proc.setProcState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY) { 3014 if (DEBUG_PSS) Slog.d(TAG_PSS, "May not keep " + proc + ": pss=" + proc.lastCachedPss); 3015 if (proc.lastCachedPss >= mProcessList.getCachedRestoreThresholdKb()) { 3016 if (proc.baseProcessTracker != null) { 3017 proc.baseProcessTracker.reportCachedKill(proc.pkgList, proc.lastCachedPss); 3018 } 3019 proc.kill(Long.toString(proc.lastCachedPss) + "k from cached", true); 3020 } 3021 } 3022 return proc; 3023 } 3024 3025 void ensurePackageDexOpt(String packageName) { 3026 IPackageManager pm = AppGlobals.getPackageManager(); 3027 try { 3028 if (pm.performDexOptIfNeeded(packageName, null /* instruction set */)) { 3029 mDidDexOpt = true; 3030 } 3031 } catch (RemoteException e) { 3032 } 3033 } 3034 3035 boolean isNextTransitionForward() { 3036 int transit = mWindowManager.getPendingAppTransition(); 3037 return transit == AppTransition.TRANSIT_ACTIVITY_OPEN 3038 || transit == AppTransition.TRANSIT_TASK_OPEN 3039 || transit == AppTransition.TRANSIT_TASK_TO_FRONT; 3040 } 3041 3042 int startIsolatedProcess(String entryPoint, String[] entryPointArgs, 3043 String processName, String abiOverride, int uid, Runnable crashHandler) { 3044 synchronized(this) { 3045 ApplicationInfo info = new ApplicationInfo(); 3046 // In general the ApplicationInfo.uid isn't neccesarily equal to ProcessRecord.uid. 3047 // For isolated processes, the former contains the parent's uid and the latter the 3048 // actual uid of the isolated process. 3049 // In the special case introduced by this method (which is, starting an isolated 3050 // process directly from the SystemServer without an actual parent app process) the 3051 // closest thing to a parent's uid is SYSTEM_UID. 3052 // The only important thing here is to keep AI.uid != PR.uid, in order to trigger 3053 // the |isolated| logic in the ProcessRecord constructor. 3054 info.uid = Process.SYSTEM_UID; 3055 info.processName = processName; 3056 info.className = entryPoint; 3057 info.packageName = "android"; 3058 ProcessRecord proc = startProcessLocked(processName, info /* info */, 3059 false /* knownToBeDead */, 0 /* intentFlags */, "" /* hostingType */, 3060 null /* hostingName */, true /* allowWhileBooting */, true /* isolated */, 3061 uid, true /* keepIfLarge */, abiOverride, entryPoint, entryPointArgs, 3062 crashHandler); 3063 return proc != null ? proc.pid : 0; 3064 } 3065 } 3066 3067 final ProcessRecord startProcessLocked(String processName, 3068 ApplicationInfo info, boolean knownToBeDead, int intentFlags, 3069 String hostingType, ComponentName hostingName, boolean allowWhileBooting, 3070 boolean isolated, boolean keepIfLarge) { 3071 return startProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType, 3072 hostingName, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge, 3073 null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */, 3074 null /* crashHandler */); 3075 } 3076 3077 final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, 3078 boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName, 3079 boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge, 3080 String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) { 3081 long startTime = SystemClock.elapsedRealtime(); 3082 ProcessRecord app; 3083 if (!isolated) { 3084 app = getProcessRecordLocked(processName, info.uid, keepIfLarge); 3085 checkTime(startTime, "startProcess: after getProcessRecord"); 3086 3087 if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) { 3088 // If we are in the background, then check to see if this process 3089 // is bad. If so, we will just silently fail. 3090 if (mBadProcesses.get(info.processName, info.uid) != null) { 3091 if (DEBUG_PROCESSES) Slog.v(TAG, "Bad process: " + info.uid 3092 + "/" + info.processName); 3093 return null; 3094 } 3095 } else { 3096 // When the user is explicitly starting a process, then clear its 3097 // crash count so that we won't make it bad until they see at 3098 // least one crash dialog again, and make the process good again 3099 // if it had been bad. 3100 if (DEBUG_PROCESSES) Slog.v(TAG, "Clearing bad process: " + info.uid 3101 + "/" + info.processName); 3102 mProcessCrashTimes.remove(info.processName, info.uid); 3103 if (mBadProcesses.get(info.processName, info.uid) != null) { 3104 EventLog.writeEvent(EventLogTags.AM_PROC_GOOD, 3105 UserHandle.getUserId(info.uid), info.uid, 3106 info.processName); 3107 mBadProcesses.remove(info.processName, info.uid); 3108 if (app != null) { 3109 app.bad = false; 3110 } 3111 } 3112 } 3113 } else { 3114 // If this is an isolated process, it can't re-use an existing process. 3115 app = null; 3116 } 3117 3118 // We don't have to do anything more if: 3119 // (1) There is an existing application record; and 3120 // (2) The caller doesn't think it is dead, OR there is no thread 3121 // object attached to it so we know it couldn't have crashed; and 3122 // (3) There is a pid assigned to it, so it is either starting or 3123 // already running. 3124 if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "startProcess: name=" + processName 3125 + " app=" + app + " knownToBeDead=" + knownToBeDead 3126 + " thread=" + (app != null ? app.thread : null) 3127 + " pid=" + (app != null ? app.pid : -1)); 3128 if (app != null && app.pid > 0) { 3129 if (!knownToBeDead || app.thread == null) { 3130 // We already have the app running, or are waiting for it to 3131 // come up (we have a pid but not yet its thread), so keep it. 3132 if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "App already running: " + app); 3133 // If this is a new package in the process, add the package to the list 3134 app.addPackage(info.packageName, info.versionCode, mProcessStats); 3135 checkTime(startTime, "startProcess: done, added package to proc"); 3136 return app; 3137 } 3138 3139 // An application record is attached to a previous process, 3140 // clean it up now. 3141 if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG_PROCESSES, "App died: " + app); 3142 checkTime(startTime, "startProcess: bad proc running, killing"); 3143 killProcessGroup(app.info.uid, app.pid); 3144 handleAppDiedLocked(app, true, true); 3145 checkTime(startTime, "startProcess: done killing old proc"); 3146 } 3147 3148 String hostingNameStr = hostingName != null 3149 ? hostingName.flattenToShortString() : null; 3150 3151 if (app == null) { 3152 checkTime(startTime, "startProcess: creating new process record"); 3153 app = newProcessRecordLocked(info, processName, isolated, isolatedUid); 3154 if (app == null) { 3155 Slog.w(TAG, "Failed making new process record for " 3156 + processName + "/" + info.uid + " isolated=" + isolated); 3157 return null; 3158 } 3159 app.crashHandler = crashHandler; 3160 checkTime(startTime, "startProcess: done creating new process record"); 3161 } else { 3162 // If this is a new package in the process, add the package to the list 3163 app.addPackage(info.packageName, info.versionCode, mProcessStats); 3164 checkTime(startTime, "startProcess: added package to existing proc"); 3165 } 3166 3167 // If the system is not ready yet, then hold off on starting this 3168 // process until it is. 3169 if (!mProcessesReady 3170 && !isAllowedWhileBooting(info) 3171 && !allowWhileBooting) { 3172 if (!mProcessesOnHold.contains(app)) { 3173 mProcessesOnHold.add(app); 3174 } 3175 if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, 3176 "System not ready, putting on hold: " + app); 3177 checkTime(startTime, "startProcess: returning with proc on hold"); 3178 return app; 3179 } 3180 3181 checkTime(startTime, "startProcess: stepping in to startProcess"); 3182 startProcessLocked( 3183 app, hostingType, hostingNameStr, abiOverride, entryPoint, entryPointArgs); 3184 checkTime(startTime, "startProcess: done starting proc!"); 3185 return (app.pid != 0) ? app : null; 3186 } 3187 3188 boolean isAllowedWhileBooting(ApplicationInfo ai) { 3189 return (ai.flags&ApplicationInfo.FLAG_PERSISTENT) != 0; 3190 } 3191 3192 private final void startProcessLocked(ProcessRecord app, 3193 String hostingType, String hostingNameStr) { 3194 startProcessLocked(app, hostingType, hostingNameStr, null /* abiOverride */, 3195 null /* entryPoint */, null /* entryPointArgs */); 3196 } 3197 3198 private final void startProcessLocked(ProcessRecord app, String hostingType, 3199 String hostingNameStr, String abiOverride, String entryPoint, String[] entryPointArgs) { 3200 long startTime = SystemClock.elapsedRealtime(); 3201 if (app.pid > 0 && app.pid != MY_PID) { 3202 checkTime(startTime, "startProcess: removing from pids map"); 3203 synchronized (mPidsSelfLocked) { 3204 mPidsSelfLocked.remove(app.pid); 3205 mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); 3206 } 3207 checkTime(startTime, "startProcess: done removing from pids map"); 3208 app.setPid(0); 3209 } 3210 3211 if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES, 3212 "startProcessLocked removing on hold: " + app); 3213 mProcessesOnHold.remove(app); 3214 3215 checkTime(startTime, "startProcess: starting to update cpu stats"); 3216 updateCpuStats(); 3217 checkTime(startTime, "startProcess: done updating cpu stats"); 3218 3219 try { 3220 try { 3221 if (AppGlobals.getPackageManager().isPackageFrozen(app.info.packageName)) { 3222 // This is caught below as if we had failed to fork zygote 3223 throw new RuntimeException("Package " + app.info.packageName + " is frozen!"); 3224 } 3225 } catch (RemoteException e) { 3226 throw e.rethrowAsRuntimeException(); 3227 } 3228 3229 int uid = app.uid; 3230 int[] gids = null; 3231 int mountExternal = Zygote.MOUNT_EXTERNAL_NONE; 3232 if (!app.isolated) { 3233 int[] permGids = null; 3234 try { 3235 checkTime(startTime, "startProcess: getting gids from package manager"); 3236 final IPackageManager pm = AppGlobals.getPackageManager(); 3237 permGids = pm.getPackageGids(app.info.packageName, app.userId); 3238 MountServiceInternal mountServiceInternal = LocalServices.getService( 3239 MountServiceInternal.class); 3240 mountExternal = mountServiceInternal.getExternalStorageMountMode(uid, 3241 app.info.packageName); 3242 } catch (RemoteException e) { 3243 throw e.rethrowAsRuntimeException(); 3244 } 3245 3246 /* 3247 * Add shared application and profile GIDs so applications can share some 3248 * resources like shared libraries and access user-wide resources 3249 */ 3250 if (ArrayUtils.isEmpty(permGids)) { 3251 gids = new int[2]; 3252 } else { 3253 gids = new int[permGids.length + 2]; 3254 System.arraycopy(permGids, 0, gids, 2, permGids.length); 3255 } 3256 gids[0] = UserHandle.getSharedAppGid(UserHandle.getAppId(uid)); 3257 gids[1] = UserHandle.getUserGid(UserHandle.getUserId(uid)); 3258 } 3259 checkTime(startTime, "startProcess: building args"); 3260 if (mFactoryTest != FactoryTest.FACTORY_TEST_OFF) { 3261 if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL 3262 && mTopComponent != null 3263 && app.processName.equals(mTopComponent.getPackageName())) { 3264 uid = 0; 3265 } 3266 if (mFactoryTest == FactoryTest.FACTORY_TEST_HIGH_LEVEL 3267 && (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) { 3268 uid = 0; 3269 } 3270 } 3271 int debugFlags = 0; 3272 if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) { 3273 debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER; 3274 // Also turn on CheckJNI for debuggable apps. It's quite 3275 // awkward to turn on otherwise. 3276 debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI; 3277 } 3278 // Run the app in safe mode if its manifest requests so or the 3279 // system is booted in safe mode. 3280 if ((app.info.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0 || 3281 mSafeMode == true) { 3282 debugFlags |= Zygote.DEBUG_ENABLE_SAFEMODE; 3283 } 3284 if ("1".equals(SystemProperties.get("debug.checkjni"))) { 3285 debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI; 3286 } 3287 String jitDebugProperty = SystemProperties.get("debug.usejit"); 3288 if ("true".equals(jitDebugProperty)) { 3289 debugFlags |= Zygote.DEBUG_ENABLE_JIT; 3290 } else if (!"false".equals(jitDebugProperty)) { 3291 // If we didn't force disable by setting false, defer to the dalvik vm options. 3292 if ("true".equals(SystemProperties.get("dalvik.vm.usejit"))) { 3293 debugFlags |= Zygote.DEBUG_ENABLE_JIT; 3294 } 3295 } 3296 String genDebugInfoProperty = SystemProperties.get("debug.generate-debug-info"); 3297 if ("true".equals(genDebugInfoProperty)) { 3298 debugFlags |= Zygote.DEBUG_GENERATE_DEBUG_INFO; 3299 } 3300 if ("1".equals(SystemProperties.get("debug.jni.logging"))) { 3301 debugFlags |= Zygote.DEBUG_ENABLE_JNI_LOGGING; 3302 } 3303 if ("1".equals(SystemProperties.get("debug.assert"))) { 3304 debugFlags |= Zygote.DEBUG_ENABLE_ASSERT; 3305 } 3306 3307 String requiredAbi = (abiOverride != null) ? abiOverride : app.info.primaryCpuAbi; 3308 if (requiredAbi == null) { 3309 requiredAbi = Build.SUPPORTED_ABIS[0]; 3310 } 3311 3312 String instructionSet = null; 3313 if (app.info.primaryCpuAbi != null) { 3314 instructionSet = VMRuntime.getInstructionSet(app.info.primaryCpuAbi); 3315 } 3316 3317 app.gids = gids; 3318 app.requiredAbi = requiredAbi; 3319 app.instructionSet = instructionSet; 3320 3321 // Start the process. It will either succeed and return a result containing 3322 // the PID of the new process, or else throw a RuntimeException. 3323 boolean isActivityProcess = (entryPoint == null); 3324 if (entryPoint == null) entryPoint = "android.app.ActivityThread"; 3325 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Start proc: " + 3326 app.processName); 3327 checkTime(startTime, "startProcess: asking zygote to start proc"); 3328 Process.ProcessStartResult startResult = Process.start(entryPoint, 3329 app.processName, uid, uid, gids, debugFlags, mountExternal, 3330 app.info.targetSdkVersion, app.info.seinfo, requiredAbi, instructionSet, 3331 app.info.dataDir, entryPointArgs); 3332 checkTime(startTime, "startProcess: returned from zygote!"); 3333 Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 3334 3335 if (app.isolated) { 3336 mBatteryStatsService.addIsolatedUid(app.uid, app.info.uid); 3337 } 3338 mBatteryStatsService.noteProcessStart(app.processName, app.info.uid); 3339 checkTime(startTime, "startProcess: done updating battery stats"); 3340 3341 EventLog.writeEvent(EventLogTags.AM_PROC_START, 3342 UserHandle.getUserId(uid), startResult.pid, uid, 3343 app.processName, hostingType, 3344 hostingNameStr != null ? hostingNameStr : ""); 3345 3346 if (app.persistent) { 3347 Watchdog.getInstance().processStarted(app.processName, startResult.pid); 3348 } 3349 3350 checkTime(startTime, "startProcess: building log message"); 3351 StringBuilder buf = mStringBuilder; 3352 buf.setLength(0); 3353 buf.append("Start proc "); 3354 buf.append(startResult.pid); 3355 buf.append(':'); 3356 buf.append(app.processName); 3357 buf.append('/'); 3358 UserHandle.formatUid(buf, uid); 3359 if (!isActivityProcess) { 3360 buf.append(" ["); 3361 buf.append(entryPoint); 3362 buf.append("]"); 3363 } 3364 buf.append(" for "); 3365 buf.append(hostingType); 3366 if (hostingNameStr != null) { 3367 buf.append(" "); 3368 buf.append(hostingNameStr); 3369 } 3370 Slog.i(TAG, buf.toString()); 3371 app.setPid(startResult.pid); 3372 app.usingWrapper = startResult.usingWrapper; 3373 app.removed = false; 3374 app.killed = false; 3375 app.killedByAm = false; 3376 checkTime(startTime, "startProcess: starting to update pids map"); 3377 synchronized (mPidsSelfLocked) { 3378 this.mPidsSelfLocked.put(startResult.pid, app); 3379 if (isActivityProcess) { 3380 Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG); 3381 msg.obj = app; 3382 mHandler.sendMessageDelayed(msg, startResult.usingWrapper 3383 ? PROC_START_TIMEOUT_WITH_WRAPPER : PROC_START_TIMEOUT); 3384 } 3385 } 3386 checkTime(startTime, "startProcess: done updating pids map"); 3387 } catch (RuntimeException e) { 3388 // XXX do better error recovery. 3389 app.setPid(0); 3390 mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid); 3391 if (app.isolated) { 3392 mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid); 3393 } 3394 Slog.e(TAG, "Failure starting process " + app.processName, e); 3395 } 3396 } 3397 3398 void updateUsageStats(ActivityRecord component, boolean resumed) { 3399 if (DEBUG_SWITCH) Slog.d(TAG_SWITCH, 3400 "updateUsageStats: comp=" + component + "res=" + resumed); 3401 final BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 3402 if (resumed) { 3403 if (mUsageStatsService != null) { 3404 mUsageStatsService.reportEvent(component.realActivity, component.userId, 3405 UsageEvents.Event.MOVE_TO_FOREGROUND); 3406 } 3407 synchronized (stats) { 3408 stats.noteActivityResumedLocked(component.app.uid); 3409 } 3410 } else { 3411 if (mUsageStatsService != null) { 3412 mUsageStatsService.reportEvent(component.realActivity, component.userId, 3413 UsageEvents.Event.MOVE_TO_BACKGROUND); 3414 } 3415 synchronized (stats) { 3416 stats.noteActivityPausedLocked(component.app.uid); 3417 } 3418 } 3419 } 3420 3421 Intent getHomeIntent() { 3422 Intent intent = new Intent(mTopAction, mTopData != null ? Uri.parse(mTopData) : null); 3423 intent.setComponent(mTopComponent); 3424 if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) { 3425 intent.addCategory(Intent.CATEGORY_HOME); 3426 } 3427 return intent; 3428 } 3429 3430 boolean startHomeActivityLocked(int userId, String reason) { 3431 if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL 3432 && mTopAction == null) { 3433 // We are running in factory test mode, but unable to find 3434 // the factory test app, so just sit around displaying the 3435 // error message and don't try to start anything. 3436 return false; 3437 } 3438 Intent intent = getHomeIntent(); 3439 ActivityInfo aInfo = 3440 resolveActivityInfo(intent, STOCK_PM_FLAGS, userId); 3441 if (aInfo != null) { 3442 intent.setComponent(new ComponentName( 3443 aInfo.applicationInfo.packageName, aInfo.name)); 3444 // Don't do this if the home app is currently being 3445 // instrumented. 3446 aInfo = new ActivityInfo(aInfo); 3447 aInfo.applicationInfo = getAppInfoForUser(aInfo.applicationInfo, userId); 3448 ProcessRecord app = getProcessRecordLocked(aInfo.processName, 3449 aInfo.applicationInfo.uid, true); 3450 if (app == null || app.instrumentationClass == null) { 3451 intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK); 3452 mStackSupervisor.startHomeActivity(intent, aInfo, reason); 3453 } 3454 } 3455 3456 return true; 3457 } 3458 3459 private ActivityInfo resolveActivityInfo(Intent intent, int flags, int userId) { 3460 ActivityInfo ai = null; 3461 ComponentName comp = intent.getComponent(); 3462 try { 3463 if (comp != null) { 3464 // Factory test. 3465 ai = AppGlobals.getPackageManager().getActivityInfo(comp, flags, userId); 3466 } else { 3467 ResolveInfo info = AppGlobals.getPackageManager().resolveIntent( 3468 intent, 3469 intent.resolveTypeIfNeeded(mContext.getContentResolver()), 3470 flags, userId); 3471 3472 if (info != null) { 3473 ai = info.activityInfo; 3474 } 3475 } 3476 } catch (RemoteException e) { 3477 // ignore 3478 } 3479 3480 return ai; 3481 } 3482 3483 /** 3484 * Starts the "new version setup screen" if appropriate. 3485 */ 3486 void startSetupActivityLocked() { 3487 // Only do this once per boot. 3488 if (mCheckedForSetup) { 3489 return; 3490 } 3491 3492 // We will show this screen if the current one is a different 3493 // version than the last one shown, and we are not running in 3494 // low-level factory test mode. 3495 final ContentResolver resolver = mContext.getContentResolver(); 3496 if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL && 3497 Settings.Global.getInt(resolver, 3498 Settings.Global.DEVICE_PROVISIONED, 0) != 0) { 3499 mCheckedForSetup = true; 3500 3501 // See if we should be showing the platform update setup UI. 3502 Intent intent = new Intent(Intent.ACTION_UPGRADE_SETUP); 3503 List<ResolveInfo> ris = mContext.getPackageManager() 3504 .queryIntentActivities(intent, PackageManager.GET_META_DATA); 3505 3506 // We don't allow third party apps to replace this. 3507 ResolveInfo ri = null; 3508 for (int i=0; ris != null && i<ris.size(); i++) { 3509 if ((ris.get(i).activityInfo.applicationInfo.flags 3510 & ApplicationInfo.FLAG_SYSTEM) != 0) { 3511 ri = ris.get(i); 3512 break; 3513 } 3514 } 3515 3516 if (ri != null) { 3517 String vers = ri.activityInfo.metaData != null 3518 ? ri.activityInfo.metaData.getString(Intent.METADATA_SETUP_VERSION) 3519 : null; 3520 if (vers == null && ri.activityInfo.applicationInfo.metaData != null) { 3521 vers = ri.activityInfo.applicationInfo.metaData.getString( 3522 Intent.METADATA_SETUP_VERSION); 3523 } 3524 String lastVers = Settings.Secure.getString( 3525 resolver, Settings.Secure.LAST_SETUP_SHOWN); 3526 if (vers != null && !vers.equals(lastVers)) { 3527 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 3528 intent.setComponent(new ComponentName( 3529 ri.activityInfo.packageName, ri.activityInfo.name)); 3530 mStackSupervisor.startActivityLocked(null, intent, null, ri.activityInfo, 3531 null, null, null, null, 0, 0, 0, null, 0, 0, 0, null, false, false, 3532 null, null, null); 3533 } 3534 } 3535 } 3536 } 3537 3538 CompatibilityInfo compatibilityInfoForPackageLocked(ApplicationInfo ai) { 3539 return mCompatModePackages.compatibilityInfoForPackageLocked(ai); 3540 } 3541 3542 void enforceNotIsolatedCaller(String caller) { 3543 if (UserHandle.isIsolated(Binder.getCallingUid())) { 3544 throw new SecurityException("Isolated process not allowed to call " + caller); 3545 } 3546 } 3547 3548 void enforceShellRestriction(String restriction, int userHandle) { 3549 if (Binder.getCallingUid() == Process.SHELL_UID) { 3550 if (userHandle < 0 3551 || mUserManager.hasUserRestriction(restriction, userHandle)) { 3552 throw new SecurityException("Shell does not have permission to access user " 3553 + userHandle); 3554 } 3555 } 3556 } 3557 3558 @Override 3559 public int getFrontActivityScreenCompatMode() { 3560 enforceNotIsolatedCaller("getFrontActivityScreenCompatMode"); 3561 synchronized (this) { 3562 return mCompatModePackages.getFrontActivityScreenCompatModeLocked(); 3563 } 3564 } 3565 3566 @Override 3567 public void setFrontActivityScreenCompatMode(int mode) { 3568 enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY, 3569 "setFrontActivityScreenCompatMode"); 3570 synchronized (this) { 3571 mCompatModePackages.setFrontActivityScreenCompatModeLocked(mode); 3572 } 3573 } 3574 3575 @Override 3576 public int getPackageScreenCompatMode(String packageName) { 3577 enforceNotIsolatedCaller("getPackageScreenCompatMode"); 3578 synchronized (this) { 3579 return mCompatModePackages.getPackageScreenCompatModeLocked(packageName); 3580 } 3581 } 3582 3583 @Override 3584 public void setPackageScreenCompatMode(String packageName, int mode) { 3585 enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY, 3586 "setPackageScreenCompatMode"); 3587 synchronized (this) { 3588 mCompatModePackages.setPackageScreenCompatModeLocked(packageName, mode); 3589 } 3590 } 3591 3592 @Override 3593 public boolean getPackageAskScreenCompat(String packageName) { 3594 enforceNotIsolatedCaller("getPackageAskScreenCompat"); 3595 synchronized (this) { 3596 return mCompatModePackages.getPackageAskCompatModeLocked(packageName); 3597 } 3598 } 3599 3600 @Override 3601 public void setPackageAskScreenCompat(String packageName, boolean ask) { 3602 enforceCallingPermission(android.Manifest.permission.SET_SCREEN_COMPATIBILITY, 3603 "setPackageAskScreenCompat"); 3604 synchronized (this) { 3605 mCompatModePackages.setPackageAskCompatModeLocked(packageName, ask); 3606 } 3607 } 3608 3609 private boolean hasUsageStatsPermission(String callingPackage) { 3610 final int mode = mAppOpsService.checkOperation(AppOpsManager.OP_GET_USAGE_STATS, 3611 Binder.getCallingUid(), callingPackage); 3612 if (mode == AppOpsManager.MODE_DEFAULT) { 3613 return checkCallingPermission(Manifest.permission.PACKAGE_USAGE_STATS) 3614 == PackageManager.PERMISSION_GRANTED; 3615 } 3616 return mode == AppOpsManager.MODE_ALLOWED; 3617 } 3618 3619 @Override 3620 public int getPackageProcessState(String packageName, String callingPackage) { 3621 if (!hasUsageStatsPermission(callingPackage)) { 3622 enforceCallingPermission(android.Manifest.permission.GET_PACKAGE_IMPORTANCE, 3623 "getPackageProcessState"); 3624 } 3625 3626 int procState = ActivityManager.PROCESS_STATE_NONEXISTENT; 3627 synchronized (this) { 3628 for (int i=mLruProcesses.size()-1; i>=0; i--) { 3629 final ProcessRecord proc = mLruProcesses.get(i); 3630 if (procState == ActivityManager.PROCESS_STATE_NONEXISTENT 3631 || procState > proc.setProcState) { 3632 boolean found = false; 3633 for (int j=proc.pkgList.size()-1; j>=0 && !found; j--) { 3634 if (proc.pkgList.keyAt(j).equals(packageName)) { 3635 procState = proc.setProcState; 3636 found = true; 3637 } 3638 } 3639 if (proc.pkgDeps != null && !found) { 3640 for (int j=proc.pkgDeps.size()-1; j>=0; j--) { 3641 if (proc.pkgDeps.valueAt(j).equals(packageName)) { 3642 procState = proc.setProcState; 3643 break; 3644 } 3645 } 3646 } 3647 } 3648 } 3649 } 3650 return procState; 3651 } 3652 3653 @Override 3654 public boolean setProcessMemoryTrimLevel(String process, int userId, int level) { 3655 synchronized (this) { 3656 final ProcessRecord app = findProcessLocked(process, userId, "setProcessMemoryTrimLevel"); 3657 if (app == null) { 3658 return false; 3659 } 3660 if (app.trimMemoryLevel < level && app.thread != null && 3661 (level < ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN || 3662 app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND)) { 3663 try { 3664 app.thread.scheduleTrimMemory(level); 3665 app.trimMemoryLevel = level; 3666 return true; 3667 } catch (RemoteException e) { 3668 // Fallthrough to failure case. 3669 } 3670 } 3671 } 3672 return false; 3673 } 3674 3675 private void dispatchProcessesChanged() { 3676 int N; 3677 synchronized (this) { 3678 N = mPendingProcessChanges.size(); 3679 if (mActiveProcessChanges.length < N) { 3680 mActiveProcessChanges = new ProcessChangeItem[N]; 3681 } 3682 mPendingProcessChanges.toArray(mActiveProcessChanges); 3683 mPendingProcessChanges.clear(); 3684 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 3685 "*** Delivering " + N + " process changes"); 3686 } 3687 3688 int i = mProcessObservers.beginBroadcast(); 3689 while (i > 0) { 3690 i--; 3691 final IProcessObserver observer = mProcessObservers.getBroadcastItem(i); 3692 if (observer != null) { 3693 try { 3694 for (int j=0; j<N; j++) { 3695 ProcessChangeItem item = mActiveProcessChanges[j]; 3696 if ((item.changes&ProcessChangeItem.CHANGE_ACTIVITIES) != 0) { 3697 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 3698 "ACTIVITIES CHANGED pid=" + item.pid + " uid=" 3699 + item.uid + ": " + item.foregroundActivities); 3700 observer.onForegroundActivitiesChanged(item.pid, item.uid, 3701 item.foregroundActivities); 3702 } 3703 if ((item.changes&ProcessChangeItem.CHANGE_PROCESS_STATE) != 0) { 3704 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 3705 "PROCSTATE CHANGED pid=" + item.pid + " uid=" + item.uid 3706 + ": " + item.processState); 3707 observer.onProcessStateChanged(item.pid, item.uid, item.processState); 3708 } 3709 } 3710 } catch (RemoteException e) { 3711 } 3712 } 3713 } 3714 mProcessObservers.finishBroadcast(); 3715 3716 synchronized (this) { 3717 for (int j=0; j<N; j++) { 3718 mAvailProcessChanges.add(mActiveProcessChanges[j]); 3719 } 3720 } 3721 } 3722 3723 private void dispatchProcessDied(int pid, int uid) { 3724 int i = mProcessObservers.beginBroadcast(); 3725 while (i > 0) { 3726 i--; 3727 final IProcessObserver observer = mProcessObservers.getBroadcastItem(i); 3728 if (observer != null) { 3729 try { 3730 observer.onProcessDied(pid, uid); 3731 } catch (RemoteException e) { 3732 } 3733 } 3734 } 3735 mProcessObservers.finishBroadcast(); 3736 } 3737 3738 private void dispatchUidsChanged() { 3739 int N; 3740 synchronized (this) { 3741 N = mPendingUidChanges.size(); 3742 if (mActiveUidChanges.length < N) { 3743 mActiveUidChanges = new UidRecord.ChangeItem[N]; 3744 } 3745 for (int i=0; i<N; i++) { 3746 final UidRecord.ChangeItem change = mPendingUidChanges.get(i); 3747 mActiveUidChanges[i] = change; 3748 change.uidRecord.pendingChange = null; 3749 change.uidRecord = null; 3750 } 3751 mPendingUidChanges.clear(); 3752 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 3753 "*** Delivering " + N + " uid changes"); 3754 } 3755 3756 if (mLocalPowerManager != null) { 3757 for (int j=0; j<N; j++) { 3758 UidRecord.ChangeItem item = mActiveUidChanges[j]; 3759 if (item.gone) { 3760 mLocalPowerManager.uidGone(item.uid); 3761 } else { 3762 mLocalPowerManager.updateUidProcState(item.uid, item.processState); 3763 } 3764 } 3765 } 3766 3767 int i = mUidObservers.beginBroadcast(); 3768 while (i > 0) { 3769 i--; 3770 final IUidObserver observer = mUidObservers.getBroadcastItem(i); 3771 if (observer != null) { 3772 try { 3773 for (int j=0; j<N; j++) { 3774 UidRecord.ChangeItem item = mActiveUidChanges[j]; 3775 if (item.gone) { 3776 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 3777 "UID gone uid=" + item.uid); 3778 observer.onUidGone(item.uid); 3779 } else { 3780 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 3781 "UID CHANGED uid=" + item.uid 3782 + ": " + item.processState); 3783 observer.onUidStateChanged(item.uid, item.processState); 3784 } 3785 } 3786 } catch (RemoteException e) { 3787 } 3788 } 3789 } 3790 mUidObservers.finishBroadcast(); 3791 3792 synchronized (this) { 3793 for (int j=0; j<N; j++) { 3794 mAvailUidChanges.add(mActiveUidChanges[j]); 3795 } 3796 } 3797 } 3798 3799 @Override 3800 public final int startActivity(IApplicationThread caller, String callingPackage, 3801 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, 3802 int startFlags, ProfilerInfo profilerInfo, Bundle options) { 3803 return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, 3804 resultWho, requestCode, startFlags, profilerInfo, options, 3805 UserHandle.getCallingUserId()); 3806 } 3807 3808 @Override 3809 public final int startActivityAsUser(IApplicationThread caller, String callingPackage, 3810 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, 3811 int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) { 3812 enforceNotIsolatedCaller("startActivity"); 3813 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 3814 false, ALLOW_FULL_ONLY, "startActivity", null); 3815 // TODO: Switch to user app stacks here. 3816 return mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, 3817 resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, 3818 profilerInfo, null, null, options, false, userId, null, null); 3819 } 3820 3821 @Override 3822 public final int startActivityAsCaller(IApplicationThread caller, String callingPackage, 3823 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, 3824 int startFlags, ProfilerInfo profilerInfo, Bundle options, boolean ignoreTargetSecurity, 3825 int userId) { 3826 3827 // This is very dangerous -- it allows you to perform a start activity (including 3828 // permission grants) as any app that may launch one of your own activities. So 3829 // we will only allow this to be done from activities that are part of the core framework, 3830 // and then only when they are running as the system. 3831 final ActivityRecord sourceRecord; 3832 final int targetUid; 3833 final String targetPackage; 3834 synchronized (this) { 3835 if (resultTo == null) { 3836 throw new SecurityException("Must be called from an activity"); 3837 } 3838 sourceRecord = mStackSupervisor.isInAnyStackLocked(resultTo); 3839 if (sourceRecord == null) { 3840 throw new SecurityException("Called with bad activity token: " + resultTo); 3841 } 3842 if (!sourceRecord.info.packageName.equals("android")) { 3843 throw new SecurityException( 3844 "Must be called from an activity that is declared in the android package"); 3845 } 3846 if (sourceRecord.app == null) { 3847 throw new SecurityException("Called without a process attached to activity"); 3848 } 3849 if (UserHandle.getAppId(sourceRecord.app.uid) != Process.SYSTEM_UID) { 3850 // This is still okay, as long as this activity is running under the 3851 // uid of the original calling activity. 3852 if (sourceRecord.app.uid != sourceRecord.launchedFromUid) { 3853 throw new SecurityException( 3854 "Calling activity in uid " + sourceRecord.app.uid 3855 + " must be system uid or original calling uid " 3856 + sourceRecord.launchedFromUid); 3857 } 3858 } 3859 if (ignoreTargetSecurity) { 3860 if (intent.getComponent() == null) { 3861 throw new SecurityException( 3862 "Component must be specified with ignoreTargetSecurity"); 3863 } 3864 if (intent.getSelector() != null) { 3865 throw new SecurityException( 3866 "Selector not allowed with ignoreTargetSecurity"); 3867 } 3868 } 3869 targetUid = sourceRecord.launchedFromUid; 3870 targetPackage = sourceRecord.launchedFromPackage; 3871 } 3872 3873 if (userId == UserHandle.USER_NULL) { 3874 userId = UserHandle.getUserId(sourceRecord.app.uid); 3875 } 3876 3877 // TODO: Switch to user app stacks here. 3878 try { 3879 int ret = mStackSupervisor.startActivityMayWait(null, targetUid, targetPackage, intent, 3880 resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, null, 3881 null, null, options, ignoreTargetSecurity, userId, null, null); 3882 return ret; 3883 } catch (SecurityException e) { 3884 // XXX need to figure out how to propagate to original app. 3885 // A SecurityException here is generally actually a fault of the original 3886 // calling activity (such as a fairly granting permissions), so propagate it 3887 // back to them. 3888 /* 3889 StringBuilder msg = new StringBuilder(); 3890 msg.append("While launching"); 3891 msg.append(intent.toString()); 3892 msg.append(": "); 3893 msg.append(e.getMessage()); 3894 */ 3895 throw e; 3896 } 3897 } 3898 3899 @Override 3900 public final WaitResult startActivityAndWait(IApplicationThread caller, String callingPackage, 3901 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, 3902 int startFlags, ProfilerInfo profilerInfo, Bundle options, int userId) { 3903 enforceNotIsolatedCaller("startActivityAndWait"); 3904 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 3905 false, ALLOW_FULL_ONLY, "startActivityAndWait", null); 3906 WaitResult res = new WaitResult(); 3907 // TODO: Switch to user app stacks here. 3908 mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, resolvedType, 3909 null, null, resultTo, resultWho, requestCode, startFlags, profilerInfo, res, null, 3910 options, false, userId, null, null); 3911 return res; 3912 } 3913 3914 @Override 3915 public final int startActivityWithConfig(IApplicationThread caller, String callingPackage, 3916 Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, 3917 int startFlags, Configuration config, Bundle options, int userId) { 3918 enforceNotIsolatedCaller("startActivityWithConfig"); 3919 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 3920 false, ALLOW_FULL_ONLY, "startActivityWithConfig", null); 3921 // TODO: Switch to user app stacks here. 3922 int ret = mStackSupervisor.startActivityMayWait(caller, -1, callingPackage, intent, 3923 resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, 3924 null, null, config, options, false, userId, null, null); 3925 return ret; 3926 } 3927 3928 @Override 3929 public int startActivityIntentSender(IApplicationThread caller, IntentSender intent, 3930 Intent fillInIntent, String resolvedType, IBinder resultTo, String resultWho, 3931 int requestCode, int flagsMask, int flagsValues, Bundle options) 3932 throws TransactionTooLargeException { 3933 enforceNotIsolatedCaller("startActivityIntentSender"); 3934 // Refuse possible leaked file descriptors 3935 if (fillInIntent != null && fillInIntent.hasFileDescriptors()) { 3936 throw new IllegalArgumentException("File descriptors passed in Intent"); 3937 } 3938 3939 IIntentSender sender = intent.getTarget(); 3940 if (!(sender instanceof PendingIntentRecord)) { 3941 throw new IllegalArgumentException("Bad PendingIntent object"); 3942 } 3943 3944 PendingIntentRecord pir = (PendingIntentRecord)sender; 3945 3946 synchronized (this) { 3947 // If this is coming from the currently resumed activity, it is 3948 // effectively saying that app switches are allowed at this point. 3949 final ActivityStack stack = getFocusedStack(); 3950 if (stack.mResumedActivity != null && 3951 stack.mResumedActivity.info.applicationInfo.uid == Binder.getCallingUid()) { 3952 mAppSwitchesAllowedTime = 0; 3953 } 3954 } 3955 int ret = pir.sendInner(0, fillInIntent, resolvedType, null, null, 3956 resultTo, resultWho, requestCode, flagsMask, flagsValues, options, null); 3957 return ret; 3958 } 3959 3960 @Override 3961 public int startVoiceActivity(String callingPackage, int callingPid, int callingUid, 3962 Intent intent, String resolvedType, IVoiceInteractionSession session, 3963 IVoiceInteractor interactor, int startFlags, ProfilerInfo profilerInfo, 3964 Bundle options, int userId) { 3965 if (checkCallingPermission(Manifest.permission.BIND_VOICE_INTERACTION) 3966 != PackageManager.PERMISSION_GRANTED) { 3967 String msg = "Permission Denial: startVoiceActivity() from pid=" 3968 + Binder.getCallingPid() 3969 + ", uid=" + Binder.getCallingUid() 3970 + " requires " + android.Manifest.permission.BIND_VOICE_INTERACTION; 3971 Slog.w(TAG, msg); 3972 throw new SecurityException(msg); 3973 } 3974 if (session == null || interactor == null) { 3975 throw new NullPointerException("null session or interactor"); 3976 } 3977 userId = handleIncomingUser(callingPid, callingUid, userId, 3978 false, ALLOW_FULL_ONLY, "startVoiceActivity", null); 3979 // TODO: Switch to user app stacks here. 3980 return mStackSupervisor.startActivityMayWait(null, callingUid, callingPackage, intent, 3981 resolvedType, session, interactor, null, null, 0, startFlags, profilerInfo, null, 3982 null, options, false, userId, null, null); 3983 } 3984 3985 @Override 3986 public void setVoiceKeepAwake(IVoiceInteractionSession session, boolean keepAwake) { 3987 synchronized (this) { 3988 if (mRunningVoice != null && mRunningVoice.asBinder() == session.asBinder()) { 3989 if (keepAwake) { 3990 mVoiceWakeLock.acquire(); 3991 } else { 3992 mVoiceWakeLock.release(); 3993 } 3994 } 3995 } 3996 } 3997 3998 @Override 3999 public boolean startNextMatchingActivity(IBinder callingActivity, 4000 Intent intent, Bundle options) { 4001 // Refuse possible leaked file descriptors 4002 if (intent != null && intent.hasFileDescriptors() == true) { 4003 throw new IllegalArgumentException("File descriptors passed in Intent"); 4004 } 4005 4006 synchronized (this) { 4007 final ActivityRecord r = ActivityRecord.isInStackLocked(callingActivity); 4008 if (r == null) { 4009 ActivityOptions.abort(options); 4010 return false; 4011 } 4012 if (r.app == null || r.app.thread == null) { 4013 // The caller is not running... d'oh! 4014 ActivityOptions.abort(options); 4015 return false; 4016 } 4017 intent = new Intent(intent); 4018 // The caller is not allowed to change the data. 4019 intent.setDataAndType(r.intent.getData(), r.intent.getType()); 4020 // And we are resetting to find the next component... 4021 intent.setComponent(null); 4022 4023 final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0); 4024 4025 ActivityInfo aInfo = null; 4026 try { 4027 List<ResolveInfo> resolves = 4028 AppGlobals.getPackageManager().queryIntentActivities( 4029 intent, r.resolvedType, 4030 PackageManager.MATCH_DEFAULT_ONLY | STOCK_PM_FLAGS, 4031 UserHandle.getCallingUserId()); 4032 4033 // Look for the original activity in the list... 4034 final int N = resolves != null ? resolves.size() : 0; 4035 for (int i=0; i<N; i++) { 4036 ResolveInfo rInfo = resolves.get(i); 4037 if (rInfo.activityInfo.packageName.equals(r.packageName) 4038 && rInfo.activityInfo.name.equals(r.info.name)) { 4039 // We found the current one... the next matching is 4040 // after it. 4041 i++; 4042 if (i<N) { 4043 aInfo = resolves.get(i).activityInfo; 4044 } 4045 if (debug) { 4046 Slog.v(TAG, "Next matching activity: found current " + r.packageName 4047 + "/" + r.info.name); 4048 Slog.v(TAG, "Next matching activity: next is " + aInfo.packageName 4049 + "/" + aInfo.name); 4050 } 4051 break; 4052 } 4053 } 4054 } catch (RemoteException e) { 4055 } 4056 4057 if (aInfo == null) { 4058 // Nobody who is next! 4059 ActivityOptions.abort(options); 4060 if (debug) Slog.d(TAG, "Next matching activity: nothing found"); 4061 return false; 4062 } 4063 4064 intent.setComponent(new ComponentName( 4065 aInfo.applicationInfo.packageName, aInfo.name)); 4066 intent.setFlags(intent.getFlags()&~( 4067 Intent.FLAG_ACTIVITY_FORWARD_RESULT| 4068 Intent.FLAG_ACTIVITY_CLEAR_TOP| 4069 Intent.FLAG_ACTIVITY_MULTIPLE_TASK| 4070 Intent.FLAG_ACTIVITY_NEW_TASK)); 4071 4072 // Okay now we need to start the new activity, replacing the 4073 // currently running activity. This is a little tricky because 4074 // we want to start the new one as if the current one is finished, 4075 // but not finish the current one first so that there is no flicker. 4076 // And thus... 4077 final boolean wasFinishing = r.finishing; 4078 r.finishing = true; 4079 4080 // Propagate reply information over to the new activity. 4081 final ActivityRecord resultTo = r.resultTo; 4082 final String resultWho = r.resultWho; 4083 final int requestCode = r.requestCode; 4084 r.resultTo = null; 4085 if (resultTo != null) { 4086 resultTo.removeResultsLocked(r, resultWho, requestCode); 4087 } 4088 4089 final long origId = Binder.clearCallingIdentity(); 4090 int res = mStackSupervisor.startActivityLocked(r.app.thread, intent, 4091 r.resolvedType, aInfo, null, null, resultTo != null ? resultTo.appToken : null, 4092 resultWho, requestCode, -1, r.launchedFromUid, r.launchedFromPackage, 4093 -1, r.launchedFromUid, 0, options, false, false, null, null, null); 4094 Binder.restoreCallingIdentity(origId); 4095 4096 r.finishing = wasFinishing; 4097 if (res != ActivityManager.START_SUCCESS) { 4098 return false; 4099 } 4100 return true; 4101 } 4102 } 4103 4104 @Override 4105 public final int startActivityFromRecents(int taskId, Bundle options) { 4106 if (checkCallingPermission(START_TASKS_FROM_RECENTS) != PackageManager.PERMISSION_GRANTED) { 4107 String msg = "Permission Denial: startActivityFromRecents called without " + 4108 START_TASKS_FROM_RECENTS; 4109 Slog.w(TAG, msg); 4110 throw new SecurityException(msg); 4111 } 4112 return startActivityFromRecentsInner(taskId, options); 4113 } 4114 4115 final int startActivityFromRecentsInner(int taskId, Bundle options) { 4116 final TaskRecord task; 4117 final int callingUid; 4118 final String callingPackage; 4119 final Intent intent; 4120 final int userId; 4121 synchronized (this) { 4122 task = mStackSupervisor.anyTaskForIdLocked(taskId); 4123 if (task == null) { 4124 throw new IllegalArgumentException("Task " + taskId + " not found."); 4125 } 4126 if (task.getRootActivity() != null) { 4127 moveTaskToFrontLocked(task.taskId, 0, null); 4128 return ActivityManager.START_TASK_TO_FRONT; 4129 } 4130 callingUid = task.mCallingUid; 4131 callingPackage = task.mCallingPackage; 4132 intent = task.intent; 4133 intent.addFlags(Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY); 4134 userId = task.userId; 4135 } 4136 return startActivityInPackage(callingUid, callingPackage, intent, null, null, null, 0, 0, 4137 options, userId, null, task); 4138 } 4139 4140 final int startActivityInPackage(int uid, String callingPackage, 4141 Intent intent, String resolvedType, IBinder resultTo, 4142 String resultWho, int requestCode, int startFlags, Bundle options, int userId, 4143 IActivityContainer container, TaskRecord inTask) { 4144 4145 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 4146 false, ALLOW_FULL_ONLY, "startActivityInPackage", null); 4147 4148 // TODO: Switch to user app stacks here. 4149 int ret = mStackSupervisor.startActivityMayWait(null, uid, callingPackage, intent, 4150 resolvedType, null, null, resultTo, resultWho, requestCode, startFlags, 4151 null, null, null, options, false, userId, container, inTask); 4152 return ret; 4153 } 4154 4155 @Override 4156 public final int startActivities(IApplicationThread caller, String callingPackage, 4157 Intent[] intents, String[] resolvedTypes, IBinder resultTo, Bundle options, 4158 int userId) { 4159 enforceNotIsolatedCaller("startActivities"); 4160 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 4161 false, ALLOW_FULL_ONLY, "startActivity", null); 4162 // TODO: Switch to user app stacks here. 4163 int ret = mStackSupervisor.startActivities(caller, -1, callingPackage, intents, 4164 resolvedTypes, resultTo, options, userId); 4165 return ret; 4166 } 4167 4168 final int startActivitiesInPackage(int uid, String callingPackage, 4169 Intent[] intents, String[] resolvedTypes, IBinder resultTo, 4170 Bundle options, int userId) { 4171 4172 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 4173 false, ALLOW_FULL_ONLY, "startActivityInPackage", null); 4174 // TODO: Switch to user app stacks here. 4175 int ret = mStackSupervisor.startActivities(null, uid, callingPackage, intents, resolvedTypes, 4176 resultTo, options, userId); 4177 return ret; 4178 } 4179 4180 @Override 4181 public void reportActivityFullyDrawn(IBinder token) { 4182 synchronized (this) { 4183 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4184 if (r == null) { 4185 return; 4186 } 4187 r.reportFullyDrawnLocked(); 4188 } 4189 } 4190 4191 @Override 4192 public void setRequestedOrientation(IBinder token, int requestedOrientation) { 4193 synchronized (this) { 4194 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4195 if (r == null) { 4196 return; 4197 } 4198 if (r.task != null && r.task.mResizeable) { 4199 // Fixed screen orientation isn't supported with resizeable activities. 4200 return; 4201 } 4202 final long origId = Binder.clearCallingIdentity(); 4203 mWindowManager.setAppOrientation(r.appToken, requestedOrientation); 4204 Configuration config = mWindowManager.updateOrientationFromAppTokens( 4205 mConfiguration, r.mayFreezeScreenLocked(r.app) ? r.appToken : null); 4206 if (config != null) { 4207 r.frozenBeforeDestroy = true; 4208 if (!updateConfigurationLocked(config, r, false, false)) { 4209 mStackSupervisor.resumeTopActivitiesLocked(); 4210 } 4211 } 4212 Binder.restoreCallingIdentity(origId); 4213 } 4214 } 4215 4216 @Override 4217 public int getRequestedOrientation(IBinder token) { 4218 synchronized (this) { 4219 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4220 if (r == null) { 4221 return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; 4222 } 4223 return mWindowManager.getAppOrientation(r.appToken); 4224 } 4225 } 4226 4227 /** 4228 * This is the internal entry point for handling Activity.finish(). 4229 * 4230 * @param token The Binder token referencing the Activity we want to finish. 4231 * @param resultCode Result code, if any, from this Activity. 4232 * @param resultData Result data (Intent), if any, from this Activity. 4233 * @param finishTask Whether to finish the task associated with this Activity. Only applies to 4234 * the root Activity in the task. 4235 * 4236 * @return Returns true if the activity successfully finished, or false if it is still running. 4237 */ 4238 @Override 4239 public final boolean finishActivity(IBinder token, int resultCode, Intent resultData, 4240 boolean finishTask) { 4241 // Refuse possible leaked file descriptors 4242 if (resultData != null && resultData.hasFileDescriptors() == true) { 4243 throw new IllegalArgumentException("File descriptors passed in Intent"); 4244 } 4245 4246 synchronized(this) { 4247 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4248 if (r == null) { 4249 return true; 4250 } 4251 // Keep track of the root activity of the task before we finish it 4252 TaskRecord tr = r.task; 4253 ActivityRecord rootR = tr.getRootActivity(); 4254 if (rootR == null) { 4255 Slog.w(TAG, "Finishing task with all activities already finished"); 4256 } 4257 // Do not allow task to finish if last task in lockTask mode. Launchable priv-apps can 4258 // finish. 4259 if (tr.mLockTaskAuth != LOCK_TASK_AUTH_LAUNCHABLE_PRIV && rootR == r && 4260 mStackSupervisor.isLastLockedTask(tr)) { 4261 Slog.i(TAG, "Not finishing task in lock task mode"); 4262 mStackSupervisor.showLockTaskToast(); 4263 return false; 4264 } 4265 if (mController != null) { 4266 // Find the first activity that is not finishing. 4267 ActivityRecord next = r.task.stack.topRunningActivityLocked(token, 0); 4268 if (next != null) { 4269 // ask watcher if this is allowed 4270 boolean resumeOK = true; 4271 try { 4272 resumeOK = mController.activityResuming(next.packageName); 4273 } catch (RemoteException e) { 4274 mController = null; 4275 Watchdog.getInstance().setActivityController(null); 4276 } 4277 4278 if (!resumeOK) { 4279 Slog.i(TAG, "Not finishing activity because controller resumed"); 4280 return false; 4281 } 4282 } 4283 } 4284 final long origId = Binder.clearCallingIdentity(); 4285 try { 4286 boolean res; 4287 if (finishTask && r == rootR) { 4288 // If requested, remove the task that is associated to this activity only if it 4289 // was the root activity in the task. The result code and data is ignored 4290 // because we don't support returning them across task boundaries. 4291 res = removeTaskByIdLocked(tr.taskId, false); 4292 if (!res) { 4293 Slog.i(TAG, "Removing task failed to finish activity"); 4294 } 4295 } else { 4296 res = tr.stack.requestFinishActivityLocked(token, resultCode, 4297 resultData, "app-request", true); 4298 if (!res) { 4299 Slog.i(TAG, "Failed to finish by app-request"); 4300 } 4301 } 4302 return res; 4303 } finally { 4304 Binder.restoreCallingIdentity(origId); 4305 } 4306 } 4307 } 4308 4309 @Override 4310 public final void finishHeavyWeightApp() { 4311 if (checkCallingPermission(android.Manifest.permission.FORCE_STOP_PACKAGES) 4312 != PackageManager.PERMISSION_GRANTED) { 4313 String msg = "Permission Denial: finishHeavyWeightApp() from pid=" 4314 + Binder.getCallingPid() 4315 + ", uid=" + Binder.getCallingUid() 4316 + " requires " + android.Manifest.permission.FORCE_STOP_PACKAGES; 4317 Slog.w(TAG, msg); 4318 throw new SecurityException(msg); 4319 } 4320 4321 synchronized(this) { 4322 if (mHeavyWeightProcess == null) { 4323 return; 4324 } 4325 4326 ArrayList<ActivityRecord> activities = new ArrayList<>(mHeavyWeightProcess.activities); 4327 for (int i = 0; i < activities.size(); i++) { 4328 ActivityRecord r = activities.get(i); 4329 if (!r.finishing && r.isInStackLocked()) { 4330 r.task.stack.finishActivityLocked(r, Activity.RESULT_CANCELED, 4331 null, "finish-heavy", true); 4332 } 4333 } 4334 4335 mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG, 4336 mHeavyWeightProcess.userId, 0)); 4337 mHeavyWeightProcess = null; 4338 } 4339 } 4340 4341 @Override 4342 public void crashApplication(int uid, int initialPid, String packageName, 4343 String message) { 4344 if (checkCallingPermission(android.Manifest.permission.FORCE_STOP_PACKAGES) 4345 != PackageManager.PERMISSION_GRANTED) { 4346 String msg = "Permission Denial: crashApplication() from pid=" 4347 + Binder.getCallingPid() 4348 + ", uid=" + Binder.getCallingUid() 4349 + " requires " + android.Manifest.permission.FORCE_STOP_PACKAGES; 4350 Slog.w(TAG, msg); 4351 throw new SecurityException(msg); 4352 } 4353 4354 synchronized(this) { 4355 ProcessRecord proc = null; 4356 4357 // Figure out which process to kill. We don't trust that initialPid 4358 // still has any relation to current pids, so must scan through the 4359 // list. 4360 synchronized (mPidsSelfLocked) { 4361 for (int i=0; i<mPidsSelfLocked.size(); i++) { 4362 ProcessRecord p = mPidsSelfLocked.valueAt(i); 4363 if (p.uid != uid) { 4364 continue; 4365 } 4366 if (p.pid == initialPid) { 4367 proc = p; 4368 break; 4369 } 4370 if (p.pkgList.containsKey(packageName)) { 4371 proc = p; 4372 } 4373 } 4374 } 4375 4376 if (proc == null) { 4377 Slog.w(TAG, "crashApplication: nothing for uid=" + uid 4378 + " initialPid=" + initialPid 4379 + " packageName=" + packageName); 4380 return; 4381 } 4382 4383 if (proc.thread != null) { 4384 if (proc.pid == Process.myPid()) { 4385 Log.w(TAG, "crashApplication: trying to crash self!"); 4386 return; 4387 } 4388 long ident = Binder.clearCallingIdentity(); 4389 try { 4390 proc.thread.scheduleCrash(message); 4391 } catch (RemoteException e) { 4392 } 4393 Binder.restoreCallingIdentity(ident); 4394 } 4395 } 4396 } 4397 4398 @Override 4399 public final void finishSubActivity(IBinder token, String resultWho, 4400 int requestCode) { 4401 synchronized(this) { 4402 final long origId = Binder.clearCallingIdentity(); 4403 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4404 if (r != null) { 4405 r.task.stack.finishSubActivityLocked(r, resultWho, requestCode); 4406 } 4407 Binder.restoreCallingIdentity(origId); 4408 } 4409 } 4410 4411 @Override 4412 public boolean finishActivityAffinity(IBinder token) { 4413 synchronized(this) { 4414 final long origId = Binder.clearCallingIdentity(); 4415 try { 4416 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4417 if (r == null) { 4418 return false; 4419 } 4420 4421 // Do not allow task to finish if last task in lockTask mode. Launchable priv-apps 4422 // can finish. 4423 final TaskRecord task = r.task; 4424 if (task.mLockTaskAuth != LOCK_TASK_AUTH_LAUNCHABLE_PRIV && 4425 mStackSupervisor.isLastLockedTask(task) && task.getRootActivity() == r) { 4426 mStackSupervisor.showLockTaskToast(); 4427 return false; 4428 } 4429 return task.stack.finishActivityAffinityLocked(r); 4430 } finally { 4431 Binder.restoreCallingIdentity(origId); 4432 } 4433 } 4434 } 4435 4436 @Override 4437 public void finishVoiceTask(IVoiceInteractionSession session) { 4438 synchronized(this) { 4439 final long origId = Binder.clearCallingIdentity(); 4440 try { 4441 mStackSupervisor.finishVoiceTask(session); 4442 } finally { 4443 Binder.restoreCallingIdentity(origId); 4444 } 4445 } 4446 4447 } 4448 4449 @Override 4450 public boolean releaseActivityInstance(IBinder token) { 4451 synchronized(this) { 4452 final long origId = Binder.clearCallingIdentity(); 4453 try { 4454 ActivityRecord r = ActivityRecord.isInStackLocked(token); 4455 if (r == null) { 4456 return false; 4457 } 4458 return r.task.stack.safelyDestroyActivityLocked(r, "app-req"); 4459 } finally { 4460 Binder.restoreCallingIdentity(origId); 4461 } 4462 } 4463 } 4464 4465 @Override 4466 public void releaseSomeActivities(IApplicationThread appInt) { 4467 synchronized(this) { 4468 final long origId = Binder.clearCallingIdentity(); 4469 try { 4470 ProcessRecord app = getRecordForAppLocked(appInt); 4471 mStackSupervisor.releaseSomeActivitiesLocked(app, "low-mem"); 4472 } finally { 4473 Binder.restoreCallingIdentity(origId); 4474 } 4475 } 4476 } 4477 4478 @Override 4479 public boolean willActivityBeVisible(IBinder token) { 4480 synchronized(this) { 4481 ActivityStack stack = ActivityRecord.getStackLocked(token); 4482 if (stack != null) { 4483 return stack.willActivityBeVisibleLocked(token); 4484 } 4485 return false; 4486 } 4487 } 4488 4489 @Override 4490 public void overridePendingTransition(IBinder token, String packageName, 4491 int enterAnim, int exitAnim) { 4492 synchronized(this) { 4493 ActivityRecord self = ActivityRecord.isInStackLocked(token); 4494 if (self == null) { 4495 return; 4496 } 4497 4498 final long origId = Binder.clearCallingIdentity(); 4499 4500 if (self.state == ActivityState.RESUMED 4501 || self.state == ActivityState.PAUSING) { 4502 mWindowManager.overridePendingAppTransition(packageName, 4503 enterAnim, exitAnim, null); 4504 } 4505 4506 Binder.restoreCallingIdentity(origId); 4507 } 4508 } 4509 4510 /** 4511 * Main function for removing an existing process from the activity manager 4512 * as a result of that process going away. Clears out all connections 4513 * to the process. 4514 */ 4515 private final void handleAppDiedLocked(ProcessRecord app, 4516 boolean restarting, boolean allowRestart) { 4517 int pid = app.pid; 4518 boolean kept = cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1); 4519 if (!kept && !restarting) { 4520 removeLruProcessLocked(app); 4521 if (pid > 0) { 4522 ProcessList.remove(pid); 4523 } 4524 } 4525 4526 if (mProfileProc == app) { 4527 clearProfilerLocked(); 4528 } 4529 4530 // Remove this application's activities from active lists. 4531 boolean hasVisibleActivities = mStackSupervisor.handleAppDiedLocked(app); 4532 4533 app.activities.clear(); 4534 4535 if (app.instrumentationClass != null) { 4536 Slog.w(TAG, "Crash of app " + app.processName 4537 + " running instrumentation " + app.instrumentationClass); 4538 Bundle info = new Bundle(); 4539 info.putString("shortMsg", "Process crashed."); 4540 finishInstrumentationLocked(app, Activity.RESULT_CANCELED, info); 4541 } 4542 4543 if (!restarting && hasVisibleActivities && !mStackSupervisor.resumeTopActivitiesLocked()) { 4544 // If there was nothing to resume, and we are not already 4545 // restarting this process, but there is a visible activity that 4546 // is hosted by the process... then make sure all visible 4547 // activities are running, taking care of restarting this 4548 // process. 4549 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0); 4550 } 4551 } 4552 4553 private final int getLRURecordIndexForAppLocked(IApplicationThread thread) { 4554 IBinder threadBinder = thread.asBinder(); 4555 // Find the application record. 4556 for (int i=mLruProcesses.size()-1; i>=0; i--) { 4557 ProcessRecord rec = mLruProcesses.get(i); 4558 if (rec.thread != null && rec.thread.asBinder() == threadBinder) { 4559 return i; 4560 } 4561 } 4562 return -1; 4563 } 4564 4565 final ProcessRecord getRecordForAppLocked( 4566 IApplicationThread thread) { 4567 if (thread == null) { 4568 return null; 4569 } 4570 4571 int appIndex = getLRURecordIndexForAppLocked(thread); 4572 return appIndex >= 0 ? mLruProcesses.get(appIndex) : null; 4573 } 4574 4575 final void doLowMemReportIfNeededLocked(ProcessRecord dyingProc) { 4576 // If there are no longer any background processes running, 4577 // and the app that died was not running instrumentation, 4578 // then tell everyone we are now low on memory. 4579 boolean haveBg = false; 4580 for (int i=mLruProcesses.size()-1; i>=0; i--) { 4581 ProcessRecord rec = mLruProcesses.get(i); 4582 if (rec.thread != null 4583 && rec.setProcState >= ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 4584 haveBg = true; 4585 break; 4586 } 4587 } 4588 4589 if (!haveBg) { 4590 boolean doReport = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 4591 if (doReport) { 4592 long now = SystemClock.uptimeMillis(); 4593 if (now < (mLastMemUsageReportTime+5*60*1000)) { 4594 doReport = false; 4595 } else { 4596 mLastMemUsageReportTime = now; 4597 } 4598 } 4599 final ArrayList<ProcessMemInfo> memInfos 4600 = doReport ? new ArrayList<ProcessMemInfo>(mLruProcesses.size()) : null; 4601 EventLog.writeEvent(EventLogTags.AM_LOW_MEMORY, mLruProcesses.size()); 4602 long now = SystemClock.uptimeMillis(); 4603 for (int i=mLruProcesses.size()-1; i>=0; i--) { 4604 ProcessRecord rec = mLruProcesses.get(i); 4605 if (rec == dyingProc || rec.thread == null) { 4606 continue; 4607 } 4608 if (doReport) { 4609 memInfos.add(new ProcessMemInfo(rec.processName, rec.pid, rec.setAdj, 4610 rec.setProcState, rec.adjType, rec.makeAdjReason())); 4611 } 4612 if ((rec.lastLowMemory+GC_MIN_INTERVAL) <= now) { 4613 // The low memory report is overriding any current 4614 // state for a GC request. Make sure to do 4615 // heavy/important/visible/foreground processes first. 4616 if (rec.setAdj <= ProcessList.HEAVY_WEIGHT_APP_ADJ) { 4617 rec.lastRequestedGc = 0; 4618 } else { 4619 rec.lastRequestedGc = rec.lastLowMemory; 4620 } 4621 rec.reportLowMemory = true; 4622 rec.lastLowMemory = now; 4623 mProcessesToGc.remove(rec); 4624 addProcessToGcListLocked(rec); 4625 } 4626 } 4627 if (doReport) { 4628 Message msg = mHandler.obtainMessage(REPORT_MEM_USAGE_MSG, memInfos); 4629 mHandler.sendMessage(msg); 4630 } 4631 scheduleAppGcsLocked(); 4632 } 4633 } 4634 4635 final void appDiedLocked(ProcessRecord app) { 4636 appDiedLocked(app, app.pid, app.thread, false); 4637 } 4638 4639 final void appDiedLocked(ProcessRecord app, int pid, IApplicationThread thread, 4640 boolean fromBinderDied) { 4641 // First check if this ProcessRecord is actually active for the pid. 4642 synchronized (mPidsSelfLocked) { 4643 ProcessRecord curProc = mPidsSelfLocked.get(pid); 4644 if (curProc != app) { 4645 Slog.w(TAG, "Spurious death for " + app + ", curProc for " + pid + ": " + curProc); 4646 return; 4647 } 4648 } 4649 4650 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 4651 synchronized (stats) { 4652 stats.noteProcessDiedLocked(app.info.uid, pid); 4653 } 4654 4655 if (!app.killed) { 4656 if (!fromBinderDied) { 4657 Process.killProcessQuiet(pid); 4658 } 4659 killProcessGroup(app.info.uid, pid); 4660 app.killed = true; 4661 } 4662 4663 // Clean up already done if the process has been re-started. 4664 if (app.pid == pid && app.thread != null && 4665 app.thread.asBinder() == thread.asBinder()) { 4666 boolean doLowMem = app.instrumentationClass == null; 4667 boolean doOomAdj = doLowMem; 4668 if (!app.killedByAm) { 4669 Slog.i(TAG, "Process " + app.processName + " (pid " + pid 4670 + ") has died"); 4671 mAllowLowerMemLevel = true; 4672 } else { 4673 // Note that we always want to do oom adj to update our state with the 4674 // new number of procs. 4675 mAllowLowerMemLevel = false; 4676 doLowMem = false; 4677 } 4678 EventLog.writeEvent(EventLogTags.AM_PROC_DIED, app.userId, app.pid, app.processName); 4679 if (DEBUG_CLEANUP) Slog.v(TAG_CLEANUP, 4680 "Dying app: " + app + ", pid: " + pid + ", thread: " + thread.asBinder()); 4681 handleAppDiedLocked(app, false, true); 4682 4683 if (doOomAdj) { 4684 updateOomAdjLocked(); 4685 } 4686 if (doLowMem) { 4687 doLowMemReportIfNeededLocked(app); 4688 } 4689 } else if (app.pid != pid) { 4690 // A new process has already been started. 4691 Slog.i(TAG, "Process " + app.processName + " (pid " + pid 4692 + ") has died and restarted (pid " + app.pid + ")."); 4693 EventLog.writeEvent(EventLogTags.AM_PROC_DIED, app.userId, app.pid, app.processName); 4694 } else if (DEBUG_PROCESSES) { 4695 Slog.d(TAG_PROCESSES, "Received spurious death notification for thread " 4696 + thread.asBinder()); 4697 } 4698 } 4699 4700 /** 4701 * If a stack trace dump file is configured, dump process stack traces. 4702 * @param clearTraces causes the dump file to be erased prior to the new 4703 * traces being written, if true; when false, the new traces will be 4704 * appended to any existing file content. 4705 * @param firstPids of dalvik VM processes to dump stack traces for first 4706 * @param lastPids of dalvik VM processes to dump stack traces for last 4707 * @param nativeProcs optional list of native process names to dump stack crawls 4708 * @return file containing stack traces, or null if no dump file is configured 4709 */ 4710 public static File dumpStackTraces(boolean clearTraces, ArrayList<Integer> firstPids, 4711 ProcessCpuTracker processCpuTracker, SparseArray<Boolean> lastPids, String[] nativeProcs) { 4712 String tracesPath = SystemProperties.get("dalvik.vm.stack-trace-file", null); 4713 if (tracesPath == null || tracesPath.length() == 0) { 4714 return null; 4715 } 4716 4717 File tracesFile = new File(tracesPath); 4718 try { 4719 if (clearTraces && tracesFile.exists()) tracesFile.delete(); 4720 tracesFile.createNewFile(); 4721 FileUtils.setPermissions(tracesFile.getPath(), 0666, -1, -1); // -rw-rw-rw- 4722 } catch (IOException e) { 4723 Slog.w(TAG, "Unable to prepare ANR traces file: " + tracesPath, e); 4724 return null; 4725 } 4726 4727 dumpStackTraces(tracesPath, firstPids, processCpuTracker, lastPids, nativeProcs); 4728 return tracesFile; 4729 } 4730 4731 private static void dumpStackTraces(String tracesPath, ArrayList<Integer> firstPids, 4732 ProcessCpuTracker processCpuTracker, SparseArray<Boolean> lastPids, String[] nativeProcs) { 4733 // Use a FileObserver to detect when traces finish writing. 4734 // The order of traces is considered important to maintain for legibility. 4735 FileObserver observer = new FileObserver(tracesPath, FileObserver.CLOSE_WRITE) { 4736 @Override 4737 public synchronized void onEvent(int event, String path) { notify(); } 4738 }; 4739 4740 try { 4741 observer.startWatching(); 4742 4743 // First collect all of the stacks of the most important pids. 4744 if (firstPids != null) { 4745 try { 4746 int num = firstPids.size(); 4747 for (int i = 0; i < num; i++) { 4748 synchronized (observer) { 4749 Process.sendSignal(firstPids.get(i), Process.SIGNAL_QUIT); 4750 observer.wait(200); // Wait for write-close, give up after 200msec 4751 } 4752 } 4753 } catch (InterruptedException e) { 4754 Slog.wtf(TAG, e); 4755 } 4756 } 4757 4758 // Next collect the stacks of the native pids 4759 if (nativeProcs != null) { 4760 int[] pids = Process.getPidsForCommands(nativeProcs); 4761 if (pids != null) { 4762 for (int pid : pids) { 4763 Debug.dumpNativeBacktraceToFile(pid, tracesPath); 4764 } 4765 } 4766 } 4767 4768 // Lastly, measure CPU usage. 4769 if (processCpuTracker != null) { 4770 processCpuTracker.init(); 4771 System.gc(); 4772 processCpuTracker.update(); 4773 try { 4774 synchronized (processCpuTracker) { 4775 processCpuTracker.wait(500); // measure over 1/2 second. 4776 } 4777 } catch (InterruptedException e) { 4778 } 4779 processCpuTracker.update(); 4780 4781 // We'll take the stack crawls of just the top apps using CPU. 4782 final int N = processCpuTracker.countWorkingStats(); 4783 int numProcs = 0; 4784 for (int i=0; i<N && numProcs<5; i++) { 4785 ProcessCpuTracker.Stats stats = processCpuTracker.getWorkingStats(i); 4786 if (lastPids.indexOfKey(stats.pid) >= 0) { 4787 numProcs++; 4788 try { 4789 synchronized (observer) { 4790 Process.sendSignal(stats.pid, Process.SIGNAL_QUIT); 4791 observer.wait(200); // Wait for write-close, give up after 200msec 4792 } 4793 } catch (InterruptedException e) { 4794 Slog.wtf(TAG, e); 4795 } 4796 4797 } 4798 } 4799 } 4800 } finally { 4801 observer.stopWatching(); 4802 } 4803 } 4804 4805 final void logAppTooSlow(ProcessRecord app, long startTime, String msg) { 4806 if (true || IS_USER_BUILD) { 4807 return; 4808 } 4809 String tracesPath = SystemProperties.get("dalvik.vm.stack-trace-file", null); 4810 if (tracesPath == null || tracesPath.length() == 0) { 4811 return; 4812 } 4813 4814 StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads(); 4815 StrictMode.allowThreadDiskWrites(); 4816 try { 4817 final File tracesFile = new File(tracesPath); 4818 final File tracesDir = tracesFile.getParentFile(); 4819 final File tracesTmp = new File(tracesDir, "__tmp__"); 4820 try { 4821 if (tracesFile.exists()) { 4822 tracesTmp.delete(); 4823 tracesFile.renameTo(tracesTmp); 4824 } 4825 StringBuilder sb = new StringBuilder(); 4826 Time tobj = new Time(); 4827 tobj.set(System.currentTimeMillis()); 4828 sb.append(tobj.format("%Y-%m-%d %H:%M:%S")); 4829 sb.append(": "); 4830 TimeUtils.formatDuration(SystemClock.uptimeMillis()-startTime, sb); 4831 sb.append(" since "); 4832 sb.append(msg); 4833 FileOutputStream fos = new FileOutputStream(tracesFile); 4834 fos.write(sb.toString().getBytes()); 4835 if (app == null) { 4836 fos.write("\n*** No application process!".getBytes()); 4837 } 4838 fos.close(); 4839 FileUtils.setPermissions(tracesFile.getPath(), 0666, -1, -1); // -rw-rw-rw- 4840 } catch (IOException e) { 4841 Slog.w(TAG, "Unable to prepare slow app traces file: " + tracesPath, e); 4842 return; 4843 } 4844 4845 if (app != null) { 4846 ArrayList<Integer> firstPids = new ArrayList<Integer>(); 4847 firstPids.add(app.pid); 4848 dumpStackTraces(tracesPath, firstPids, null, null, null); 4849 } 4850 4851 File lastTracesFile = null; 4852 File curTracesFile = null; 4853 for (int i=9; i>=0; i--) { 4854 String name = String.format(Locale.US, "slow%02d.txt", i); 4855 curTracesFile = new File(tracesDir, name); 4856 if (curTracesFile.exists()) { 4857 if (lastTracesFile != null) { 4858 curTracesFile.renameTo(lastTracesFile); 4859 } else { 4860 curTracesFile.delete(); 4861 } 4862 } 4863 lastTracesFile = curTracesFile; 4864 } 4865 tracesFile.renameTo(curTracesFile); 4866 if (tracesTmp.exists()) { 4867 tracesTmp.renameTo(tracesFile); 4868 } 4869 } finally { 4870 StrictMode.setThreadPolicy(oldPolicy); 4871 } 4872 } 4873 4874 final void appNotResponding(ProcessRecord app, ActivityRecord activity, 4875 ActivityRecord parent, boolean aboveSystem, final String annotation) { 4876 ArrayList<Integer> firstPids = new ArrayList<Integer>(5); 4877 SparseArray<Boolean> lastPids = new SparseArray<Boolean>(20); 4878 4879 if (mController != null) { 4880 try { 4881 // 0 == continue, -1 = kill process immediately 4882 int res = mController.appEarlyNotResponding(app.processName, app.pid, annotation); 4883 if (res < 0 && app.pid != MY_PID) { 4884 app.kill("anr", true); 4885 } 4886 } catch (RemoteException e) { 4887 mController = null; 4888 Watchdog.getInstance().setActivityController(null); 4889 } 4890 } 4891 4892 long anrTime = SystemClock.uptimeMillis(); 4893 if (MONITOR_CPU_USAGE) { 4894 updateCpuStatsNow(); 4895 } 4896 4897 synchronized (this) { 4898 // PowerManager.reboot() can block for a long time, so ignore ANRs while shutting down. 4899 if (mShuttingDown) { 4900 Slog.i(TAG, "During shutdown skipping ANR: " + app + " " + annotation); 4901 return; 4902 } else if (app.notResponding) { 4903 Slog.i(TAG, "Skipping duplicate ANR: " + app + " " + annotation); 4904 return; 4905 } else if (app.crashing) { 4906 Slog.i(TAG, "Crashing app skipping ANR: " + app + " " + annotation); 4907 return; 4908 } 4909 4910 // In case we come through here for the same app before completing 4911 // this one, mark as anring now so we will bail out. 4912 app.notResponding = true; 4913 4914 // Log the ANR to the event log. 4915 EventLog.writeEvent(EventLogTags.AM_ANR, app.userId, app.pid, 4916 app.processName, app.info.flags, annotation); 4917 4918 // Dump thread traces as quickly as we can, starting with "interesting" processes. 4919 firstPids.add(app.pid); 4920 4921 int parentPid = app.pid; 4922 if (parent != null && parent.app != null && parent.app.pid > 0) parentPid = parent.app.pid; 4923 if (parentPid != app.pid) firstPids.add(parentPid); 4924 4925 if (MY_PID != app.pid && MY_PID != parentPid) firstPids.add(MY_PID); 4926 4927 for (int i = mLruProcesses.size() - 1; i >= 0; i--) { 4928 ProcessRecord r = mLruProcesses.get(i); 4929 if (r != null && r.thread != null) { 4930 int pid = r.pid; 4931 if (pid > 0 && pid != app.pid && pid != parentPid && pid != MY_PID) { 4932 if (r.persistent) { 4933 firstPids.add(pid); 4934 } else { 4935 lastPids.put(pid, Boolean.TRUE); 4936 } 4937 } 4938 } 4939 } 4940 } 4941 4942 // Log the ANR to the main log. 4943 StringBuilder info = new StringBuilder(); 4944 info.setLength(0); 4945 info.append("ANR in ").append(app.processName); 4946 if (activity != null && activity.shortComponentName != null) { 4947 info.append(" (").append(activity.shortComponentName).append(")"); 4948 } 4949 info.append("\n"); 4950 info.append("PID: ").append(app.pid).append("\n"); 4951 if (annotation != null) { 4952 info.append("Reason: ").append(annotation).append("\n"); 4953 } 4954 if (parent != null && parent != activity) { 4955 info.append("Parent: ").append(parent.shortComponentName).append("\n"); 4956 } 4957 4958 final ProcessCpuTracker processCpuTracker = new ProcessCpuTracker(true); 4959 4960 File tracesFile = dumpStackTraces(true, firstPids, processCpuTracker, lastPids, 4961 NATIVE_STACKS_OF_INTEREST); 4962 4963 String cpuInfo = null; 4964 if (MONITOR_CPU_USAGE) { 4965 updateCpuStatsNow(); 4966 synchronized (mProcessCpuTracker) { 4967 cpuInfo = mProcessCpuTracker.printCurrentState(anrTime); 4968 } 4969 info.append(processCpuTracker.printCurrentLoad()); 4970 info.append(cpuInfo); 4971 } 4972 4973 info.append(processCpuTracker.printCurrentState(anrTime)); 4974 4975 Slog.e(TAG, info.toString()); 4976 if (tracesFile == null) { 4977 // There is no trace file, so dump (only) the alleged culprit's threads to the log 4978 Process.sendSignal(app.pid, Process.SIGNAL_QUIT); 4979 } 4980 4981 addErrorToDropBox("anr", app, app.processName, activity, parent, annotation, 4982 cpuInfo, tracesFile, null); 4983 4984 if (mController != null) { 4985 try { 4986 // 0 == show dialog, 1 = keep waiting, -1 = kill process immediately 4987 int res = mController.appNotResponding(app.processName, app.pid, info.toString()); 4988 if (res != 0) { 4989 if (res < 0 && app.pid != MY_PID) { 4990 app.kill("anr", true); 4991 } else { 4992 synchronized (this) { 4993 mServices.scheduleServiceTimeoutLocked(app); 4994 } 4995 } 4996 return; 4997 } 4998 } catch (RemoteException e) { 4999 mController = null; 5000 Watchdog.getInstance().setActivityController(null); 5001 } 5002 } 5003 5004 // Unless configured otherwise, swallow ANRs in background processes & kill the process. 5005 boolean showBackground = Settings.Secure.getInt(mContext.getContentResolver(), 5006 Settings.Secure.ANR_SHOW_BACKGROUND, 0) != 0; 5007 5008 synchronized (this) { 5009 mBatteryStatsService.noteProcessAnr(app.processName, app.uid); 5010 5011 if (!showBackground && !app.isInterestingToUserLocked() && app.pid != MY_PID) { 5012 app.kill("bg anr", true); 5013 return; 5014 } 5015 5016 // Set the app's notResponding state, and look up the errorReportReceiver 5017 makeAppNotRespondingLocked(app, 5018 activity != null ? activity.shortComponentName : null, 5019 annotation != null ? "ANR " + annotation : "ANR", 5020 info.toString()); 5021 5022 // Bring up the infamous App Not Responding dialog 5023 Message msg = Message.obtain(); 5024 HashMap<String, Object> map = new HashMap<String, Object>(); 5025 msg.what = SHOW_NOT_RESPONDING_MSG; 5026 msg.obj = map; 5027 msg.arg1 = aboveSystem ? 1 : 0; 5028 map.put("app", app); 5029 if (activity != null) { 5030 map.put("activity", activity); 5031 } 5032 5033 mUiHandler.sendMessage(msg); 5034 } 5035 } 5036 5037 final void showLaunchWarningLocked(final ActivityRecord cur, final ActivityRecord next) { 5038 if (!mLaunchWarningShown) { 5039 mLaunchWarningShown = true; 5040 mUiHandler.post(new Runnable() { 5041 @Override 5042 public void run() { 5043 synchronized (ActivityManagerService.this) { 5044 final Dialog d = new LaunchWarningWindow(mContext, cur, next); 5045 d.show(); 5046 mUiHandler.postDelayed(new Runnable() { 5047 @Override 5048 public void run() { 5049 synchronized (ActivityManagerService.this) { 5050 d.dismiss(); 5051 mLaunchWarningShown = false; 5052 } 5053 } 5054 }, 4000); 5055 } 5056 } 5057 }); 5058 } 5059 } 5060 5061 @Override 5062 public boolean clearApplicationUserData(final String packageName, 5063 final IPackageDataObserver observer, int userId) { 5064 enforceNotIsolatedCaller("clearApplicationUserData"); 5065 if (packageName != null && packageName.equals(mDeviceOwnerName)) { 5066 throw new SecurityException("Clearing DeviceOwner data is forbidden."); 5067 } 5068 int uid = Binder.getCallingUid(); 5069 int pid = Binder.getCallingPid(); 5070 userId = handleIncomingUser(pid, uid, 5071 userId, false, ALLOW_FULL_ONLY, "clearApplicationUserData", null); 5072 long callingId = Binder.clearCallingIdentity(); 5073 try { 5074 IPackageManager pm = AppGlobals.getPackageManager(); 5075 int pkgUid = -1; 5076 synchronized(this) { 5077 try { 5078 pkgUid = pm.getPackageUid(packageName, userId); 5079 } catch (RemoteException e) { 5080 } 5081 if (pkgUid == -1) { 5082 Slog.w(TAG, "Invalid packageName: " + packageName); 5083 if (observer != null) { 5084 try { 5085 observer.onRemoveCompleted(packageName, false); 5086 } catch (RemoteException e) { 5087 Slog.i(TAG, "Observer no longer exists."); 5088 } 5089 } 5090 return false; 5091 } 5092 if (uid == pkgUid || checkComponentPermission( 5093 android.Manifest.permission.CLEAR_APP_USER_DATA, 5094 pid, uid, -1, true) 5095 == PackageManager.PERMISSION_GRANTED) { 5096 forceStopPackageLocked(packageName, pkgUid, "clear data"); 5097 } else { 5098 throw new SecurityException("PID " + pid + " does not have permission " 5099 + android.Manifest.permission.CLEAR_APP_USER_DATA + " to clear data" 5100 + " of package " + packageName); 5101 } 5102 5103 // Remove all tasks match the cleared application package and user 5104 for (int i = mRecentTasks.size() - 1; i >= 0; i--) { 5105 final TaskRecord tr = mRecentTasks.get(i); 5106 final String taskPackageName = 5107 tr.getBaseIntent().getComponent().getPackageName(); 5108 if (tr.userId != userId) continue; 5109 if (!taskPackageName.equals(packageName)) continue; 5110 removeTaskByIdLocked(tr.taskId, false); 5111 } 5112 } 5113 5114 try { 5115 // Clear application user data 5116 pm.clearApplicationUserData(packageName, observer, userId); 5117 5118 synchronized(this) { 5119 // Remove all permissions granted from/to this package 5120 removeUriPermissionsForPackageLocked(packageName, userId, true); 5121 } 5122 5123 Intent intent = new Intent(Intent.ACTION_PACKAGE_DATA_CLEARED, 5124 Uri.fromParts("package", packageName, null)); 5125 intent.putExtra(Intent.EXTRA_UID, pkgUid); 5126 broadcastIntentInPackage("android", Process.SYSTEM_UID, intent, 5127 null, null, 0, null, null, null, null, false, false, userId); 5128 } catch (RemoteException e) { 5129 } 5130 } finally { 5131 Binder.restoreCallingIdentity(callingId); 5132 } 5133 return true; 5134 } 5135 5136 @Override 5137 public void killBackgroundProcesses(final String packageName, int userId) { 5138 if (checkCallingPermission(android.Manifest.permission.KILL_BACKGROUND_PROCESSES) 5139 != PackageManager.PERMISSION_GRANTED && 5140 checkCallingPermission(android.Manifest.permission.RESTART_PACKAGES) 5141 != PackageManager.PERMISSION_GRANTED) { 5142 String msg = "Permission Denial: killBackgroundProcesses() from pid=" 5143 + Binder.getCallingPid() 5144 + ", uid=" + Binder.getCallingUid() 5145 + " requires " + android.Manifest.permission.KILL_BACKGROUND_PROCESSES; 5146 Slog.w(TAG, msg); 5147 throw new SecurityException(msg); 5148 } 5149 5150 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), 5151 userId, true, ALLOW_FULL_ONLY, "killBackgroundProcesses", null); 5152 long callingId = Binder.clearCallingIdentity(); 5153 try { 5154 IPackageManager pm = AppGlobals.getPackageManager(); 5155 synchronized(this) { 5156 int appId = -1; 5157 try { 5158 appId = UserHandle.getAppId(pm.getPackageUid(packageName, 0)); 5159 } catch (RemoteException e) { 5160 } 5161 if (appId == -1) { 5162 Slog.w(TAG, "Invalid packageName: " + packageName); 5163 return; 5164 } 5165 killPackageProcessesLocked(packageName, appId, userId, 5166 ProcessList.SERVICE_ADJ, false, true, true, false, "kill background"); 5167 } 5168 } finally { 5169 Binder.restoreCallingIdentity(callingId); 5170 } 5171 } 5172 5173 @Override 5174 public void killAllBackgroundProcesses() { 5175 if (checkCallingPermission(android.Manifest.permission.KILL_BACKGROUND_PROCESSES) 5176 != PackageManager.PERMISSION_GRANTED) { 5177 String msg = "Permission Denial: killAllBackgroundProcesses() from pid=" 5178 + Binder.getCallingPid() 5179 + ", uid=" + Binder.getCallingUid() 5180 + " requires " + android.Manifest.permission.KILL_BACKGROUND_PROCESSES; 5181 Slog.w(TAG, msg); 5182 throw new SecurityException(msg); 5183 } 5184 5185 long callingId = Binder.clearCallingIdentity(); 5186 try { 5187 synchronized(this) { 5188 ArrayList<ProcessRecord> procs = new ArrayList<ProcessRecord>(); 5189 final int NP = mProcessNames.getMap().size(); 5190 for (int ip=0; ip<NP; ip++) { 5191 SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip); 5192 final int NA = apps.size(); 5193 for (int ia=0; ia<NA; ia++) { 5194 ProcessRecord app = apps.valueAt(ia); 5195 if (app.persistent) { 5196 // we don't kill persistent processes 5197 continue; 5198 } 5199 if (app.removed) { 5200 procs.add(app); 5201 } else if (app.setAdj >= ProcessList.CACHED_APP_MIN_ADJ) { 5202 app.removed = true; 5203 procs.add(app); 5204 } 5205 } 5206 } 5207 5208 int N = procs.size(); 5209 for (int i=0; i<N; i++) { 5210 removeProcessLocked(procs.get(i), false, true, "kill all background"); 5211 } 5212 mAllowLowerMemLevel = true; 5213 updateOomAdjLocked(); 5214 doLowMemReportIfNeededLocked(null); 5215 } 5216 } finally { 5217 Binder.restoreCallingIdentity(callingId); 5218 } 5219 } 5220 5221 @Override 5222 public void forceStopPackage(final String packageName, int userId) { 5223 if (checkCallingPermission(android.Manifest.permission.FORCE_STOP_PACKAGES) 5224 != PackageManager.PERMISSION_GRANTED) { 5225 String msg = "Permission Denial: forceStopPackage() from pid=" 5226 + Binder.getCallingPid() 5227 + ", uid=" + Binder.getCallingUid() 5228 + " requires " + android.Manifest.permission.FORCE_STOP_PACKAGES; 5229 Slog.w(TAG, msg); 5230 throw new SecurityException(msg); 5231 } 5232 final int callingPid = Binder.getCallingPid(); 5233 userId = handleIncomingUser(callingPid, Binder.getCallingUid(), 5234 userId, true, ALLOW_FULL_ONLY, "forceStopPackage", null); 5235 long callingId = Binder.clearCallingIdentity(); 5236 try { 5237 IPackageManager pm = AppGlobals.getPackageManager(); 5238 synchronized(this) { 5239 int[] users = userId == UserHandle.USER_ALL 5240 ? getUsersLocked() : new int[] { userId }; 5241 for (int user : users) { 5242 int pkgUid = -1; 5243 try { 5244 pkgUid = pm.getPackageUid(packageName, user); 5245 } catch (RemoteException e) { 5246 } 5247 if (pkgUid == -1) { 5248 Slog.w(TAG, "Invalid packageName: " + packageName); 5249 continue; 5250 } 5251 try { 5252 pm.setPackageStoppedState(packageName, true, user); 5253 } catch (RemoteException e) { 5254 } catch (IllegalArgumentException e) { 5255 Slog.w(TAG, "Failed trying to unstop package " 5256 + packageName + ": " + e); 5257 } 5258 if (isUserRunningLocked(user, false)) { 5259 forceStopPackageLocked(packageName, pkgUid, "from pid " + callingPid); 5260 } 5261 } 5262 } 5263 } finally { 5264 Binder.restoreCallingIdentity(callingId); 5265 } 5266 } 5267 5268 @Override 5269 public void addPackageDependency(String packageName) { 5270 synchronized (this) { 5271 int callingPid = Binder.getCallingPid(); 5272 if (callingPid == Process.myPid()) { 5273 // Yeah, um, no. 5274 return; 5275 } 5276 ProcessRecord proc; 5277 synchronized (mPidsSelfLocked) { 5278 proc = mPidsSelfLocked.get(Binder.getCallingPid()); 5279 } 5280 if (proc != null) { 5281 if (proc.pkgDeps == null) { 5282 proc.pkgDeps = new ArraySet<String>(1); 5283 } 5284 proc.pkgDeps.add(packageName); 5285 } 5286 } 5287 } 5288 5289 /* 5290 * The pkg name and app id have to be specified. 5291 */ 5292 @Override 5293 public void killApplicationWithAppId(String pkg, int appid, String reason) { 5294 if (pkg == null) { 5295 return; 5296 } 5297 // Make sure the uid is valid. 5298 if (appid < 0) { 5299 Slog.w(TAG, "Invalid appid specified for pkg : " + pkg); 5300 return; 5301 } 5302 int callerUid = Binder.getCallingUid(); 5303 // Only the system server can kill an application 5304 if (UserHandle.getAppId(callerUid) == Process.SYSTEM_UID) { 5305 // Post an aysnc message to kill the application 5306 Message msg = mHandler.obtainMessage(KILL_APPLICATION_MSG); 5307 msg.arg1 = appid; 5308 msg.arg2 = 0; 5309 Bundle bundle = new Bundle(); 5310 bundle.putString("pkg", pkg); 5311 bundle.putString("reason", reason); 5312 msg.obj = bundle; 5313 mHandler.sendMessage(msg); 5314 } else { 5315 throw new SecurityException(callerUid + " cannot kill pkg: " + 5316 pkg); 5317 } 5318 } 5319 5320 @Override 5321 public void closeSystemDialogs(String reason) { 5322 enforceNotIsolatedCaller("closeSystemDialogs"); 5323 5324 final int pid = Binder.getCallingPid(); 5325 final int uid = Binder.getCallingUid(); 5326 final long origId = Binder.clearCallingIdentity(); 5327 try { 5328 synchronized (this) { 5329 // Only allow this from foreground processes, so that background 5330 // applications can't abuse it to prevent system UI from being shown. 5331 if (uid >= Process.FIRST_APPLICATION_UID) { 5332 ProcessRecord proc; 5333 synchronized (mPidsSelfLocked) { 5334 proc = mPidsSelfLocked.get(pid); 5335 } 5336 if (proc.curRawAdj > ProcessList.PERCEPTIBLE_APP_ADJ) { 5337 Slog.w(TAG, "Ignoring closeSystemDialogs " + reason 5338 + " from background process " + proc); 5339 return; 5340 } 5341 } 5342 closeSystemDialogsLocked(reason); 5343 } 5344 } finally { 5345 Binder.restoreCallingIdentity(origId); 5346 } 5347 } 5348 5349 void closeSystemDialogsLocked(String reason) { 5350 Intent intent = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS); 5351 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 5352 | Intent.FLAG_RECEIVER_FOREGROUND); 5353 if (reason != null) { 5354 intent.putExtra("reason", reason); 5355 } 5356 mWindowManager.closeSystemDialogs(reason); 5357 5358 mStackSupervisor.closeSystemDialogsLocked(); 5359 5360 broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, 5361 AppOpsManager.OP_NONE, null, false, false, 5362 -1, Process.SYSTEM_UID, UserHandle.USER_ALL); 5363 } 5364 5365 @Override 5366 public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids) { 5367 enforceNotIsolatedCaller("getProcessMemoryInfo"); 5368 Debug.MemoryInfo[] infos = new Debug.MemoryInfo[pids.length]; 5369 for (int i=pids.length-1; i>=0; i--) { 5370 ProcessRecord proc; 5371 int oomAdj; 5372 synchronized (this) { 5373 synchronized (mPidsSelfLocked) { 5374 proc = mPidsSelfLocked.get(pids[i]); 5375 oomAdj = proc != null ? proc.setAdj : 0; 5376 } 5377 } 5378 infos[i] = new Debug.MemoryInfo(); 5379 Debug.getMemoryInfo(pids[i], infos[i]); 5380 if (proc != null) { 5381 synchronized (this) { 5382 if (proc.thread != null && proc.setAdj == oomAdj) { 5383 // Record this for posterity if the process has been stable. 5384 proc.baseProcessTracker.addPss(infos[i].getTotalPss(), 5385 infos[i].getTotalUss(), false, proc.pkgList); 5386 } 5387 } 5388 } 5389 } 5390 return infos; 5391 } 5392 5393 @Override 5394 public long[] getProcessPss(int[] pids) { 5395 enforceNotIsolatedCaller("getProcessPss"); 5396 long[] pss = new long[pids.length]; 5397 for (int i=pids.length-1; i>=0; i--) { 5398 ProcessRecord proc; 5399 int oomAdj; 5400 synchronized (this) { 5401 synchronized (mPidsSelfLocked) { 5402 proc = mPidsSelfLocked.get(pids[i]); 5403 oomAdj = proc != null ? proc.setAdj : 0; 5404 } 5405 } 5406 long[] tmpUss = new long[1]; 5407 pss[i] = Debug.getPss(pids[i], tmpUss, null); 5408 if (proc != null) { 5409 synchronized (this) { 5410 if (proc.thread != null && proc.setAdj == oomAdj) { 5411 // Record this for posterity if the process has been stable. 5412 proc.baseProcessTracker.addPss(pss[i], tmpUss[0], false, proc.pkgList); 5413 } 5414 } 5415 } 5416 } 5417 return pss; 5418 } 5419 5420 @Override 5421 public void killApplicationProcess(String processName, int uid) { 5422 if (processName == null) { 5423 return; 5424 } 5425 5426 int callerUid = Binder.getCallingUid(); 5427 // Only the system server can kill an application 5428 if (callerUid == Process.SYSTEM_UID) { 5429 synchronized (this) { 5430 ProcessRecord app = getProcessRecordLocked(processName, uid, true); 5431 if (app != null && app.thread != null) { 5432 try { 5433 app.thread.scheduleSuicide(); 5434 } catch (RemoteException e) { 5435 // If the other end already died, then our work here is done. 5436 } 5437 } else { 5438 Slog.w(TAG, "Process/uid not found attempting kill of " 5439 + processName + " / " + uid); 5440 } 5441 } 5442 } else { 5443 throw new SecurityException(callerUid + " cannot kill app process: " + 5444 processName); 5445 } 5446 } 5447 5448 private void forceStopPackageLocked(final String packageName, int uid, String reason) { 5449 forceStopPackageLocked(packageName, UserHandle.getAppId(uid), false, 5450 false, true, false, false, UserHandle.getUserId(uid), reason); 5451 Intent intent = new Intent(Intent.ACTION_PACKAGE_RESTARTED, 5452 Uri.fromParts("package", packageName, null)); 5453 if (!mProcessesReady) { 5454 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 5455 | Intent.FLAG_RECEIVER_FOREGROUND); 5456 } 5457 intent.putExtra(Intent.EXTRA_UID, uid); 5458 intent.putExtra(Intent.EXTRA_USER_HANDLE, UserHandle.getUserId(uid)); 5459 broadcastIntentLocked(null, null, intent, 5460 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 5461 null, false, false, MY_PID, Process.SYSTEM_UID, UserHandle.getUserId(uid)); 5462 } 5463 5464 private void forceStopUserLocked(int userId, String reason) { 5465 forceStopPackageLocked(null, -1, false, false, true, false, false, userId, reason); 5466 Intent intent = new Intent(Intent.ACTION_USER_STOPPED); 5467 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 5468 | Intent.FLAG_RECEIVER_FOREGROUND); 5469 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 5470 broadcastIntentLocked(null, null, intent, 5471 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 5472 null, false, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 5473 } 5474 5475 private final boolean killPackageProcessesLocked(String packageName, int appId, 5476 int userId, int minOomAdj, boolean callerWillRestart, boolean allowRestart, 5477 boolean doit, boolean evenPersistent, String reason) { 5478 ArrayList<ProcessRecord> procs = new ArrayList<>(); 5479 5480 // Remove all processes this package may have touched: all with the 5481 // same UID (except for the system or root user), and all whose name 5482 // matches the package name. 5483 final int NP = mProcessNames.getMap().size(); 5484 for (int ip=0; ip<NP; ip++) { 5485 SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip); 5486 final int NA = apps.size(); 5487 for (int ia=0; ia<NA; ia++) { 5488 ProcessRecord app = apps.valueAt(ia); 5489 if (app.persistent && !evenPersistent) { 5490 // we don't kill persistent processes 5491 continue; 5492 } 5493 if (app.removed) { 5494 if (doit) { 5495 procs.add(app); 5496 } 5497 continue; 5498 } 5499 5500 // Skip process if it doesn't meet our oom adj requirement. 5501 if (app.setAdj < minOomAdj) { 5502 continue; 5503 } 5504 5505 // If no package is specified, we call all processes under the 5506 // give user id. 5507 if (packageName == null) { 5508 if (userId != UserHandle.USER_ALL && app.userId != userId) { 5509 continue; 5510 } 5511 if (appId >= 0 && UserHandle.getAppId(app.uid) != appId) { 5512 continue; 5513 } 5514 // Package has been specified, we want to hit all processes 5515 // that match it. We need to qualify this by the processes 5516 // that are running under the specified app and user ID. 5517 } else { 5518 final boolean isDep = app.pkgDeps != null 5519 && app.pkgDeps.contains(packageName); 5520 if (!isDep && UserHandle.getAppId(app.uid) != appId) { 5521 continue; 5522 } 5523 if (userId != UserHandle.USER_ALL && app.userId != userId) { 5524 continue; 5525 } 5526 if (!app.pkgList.containsKey(packageName) && !isDep) { 5527 continue; 5528 } 5529 } 5530 5531 // Process has passed all conditions, kill it! 5532 if (!doit) { 5533 return true; 5534 } 5535 app.removed = true; 5536 procs.add(app); 5537 } 5538 } 5539 5540 int N = procs.size(); 5541 for (int i=0; i<N; i++) { 5542 removeProcessLocked(procs.get(i), callerWillRestart, allowRestart, reason); 5543 } 5544 updateOomAdjLocked(); 5545 return N > 0; 5546 } 5547 5548 private void cleanupDisabledPackageComponentsLocked( 5549 String packageName, int userId, String[] changedClasses) { 5550 5551 Set<String> disabledClasses = null; 5552 boolean packageDisabled = false; 5553 IPackageManager pm = AppGlobals.getPackageManager(); 5554 5555 if (changedClasses == null) { 5556 // Nothing changed... 5557 return; 5558 } 5559 5560 // Determine enable/disable state of the package and its components. 5561 int enabled = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 5562 for (int i = changedClasses.length - 1; i >= 0; i--) { 5563 final String changedClass = changedClasses[i]; 5564 5565 if (changedClass.equals(packageName)) { 5566 try { 5567 // Entire package setting changed 5568 enabled = pm.getApplicationEnabledSetting(packageName, 5569 (userId != UserHandle.USER_ALL) ? userId : UserHandle.USER_OWNER); 5570 } catch (Exception e) { 5571 // No such package/component; probably racing with uninstall. In any 5572 // event it means we have nothing further to do here. 5573 return; 5574 } 5575 packageDisabled = enabled != PackageManager.COMPONENT_ENABLED_STATE_ENABLED 5576 && enabled != PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; 5577 if (packageDisabled) { 5578 // Entire package is disabled. 5579 // No need to continue to check component states. 5580 disabledClasses = null; 5581 break; 5582 } 5583 } else { 5584 try { 5585 enabled = pm.getComponentEnabledSetting( 5586 new ComponentName(packageName, changedClass), 5587 (userId != UserHandle.USER_ALL) ? userId : UserHandle.USER_OWNER); 5588 } catch (Exception e) { 5589 // As above, probably racing with uninstall. 5590 return; 5591 } 5592 if (enabled != PackageManager.COMPONENT_ENABLED_STATE_ENABLED 5593 && enabled != PackageManager.COMPONENT_ENABLED_STATE_DEFAULT) { 5594 if (disabledClasses == null) { 5595 disabledClasses = new ArraySet<>(changedClasses.length); 5596 } 5597 disabledClasses.add(changedClass); 5598 } 5599 } 5600 } 5601 5602 if (!packageDisabled && disabledClasses == null) { 5603 // Nothing to do here... 5604 return; 5605 } 5606 5607 // Clean-up disabled activities. 5608 if (mStackSupervisor.finishDisabledPackageActivitiesLocked( 5609 packageName, disabledClasses, true, false, userId) && mBooted) { 5610 mStackSupervisor.resumeTopActivitiesLocked(); 5611 mStackSupervisor.scheduleIdleLocked(); 5612 } 5613 5614 // Clean-up disabled tasks 5615 cleanupDisabledPackageTasksLocked(packageName, disabledClasses, userId); 5616 5617 // Clean-up disabled services. 5618 mServices.bringDownDisabledPackageServicesLocked( 5619 packageName, disabledClasses, userId, false, true); 5620 5621 // Clean-up disabled providers. 5622 ArrayList<ContentProviderRecord> providers = new ArrayList<>(); 5623 mProviderMap.collectPackageProvidersLocked( 5624 packageName, disabledClasses, true, false, userId, providers); 5625 for (int i = providers.size() - 1; i >= 0; i--) { 5626 removeDyingProviderLocked(null, providers.get(i), true); 5627 } 5628 5629 // Clean-up disabled broadcast receivers. 5630 for (int i = mBroadcastQueues.length - 1; i >= 0; i--) { 5631 mBroadcastQueues[i].cleanupDisabledPackageReceiversLocked( 5632 packageName, disabledClasses, userId, true); 5633 } 5634 5635 } 5636 5637 private final boolean forceStopPackageLocked(String packageName, int appId, 5638 boolean callerWillRestart, boolean purgeCache, boolean doit, 5639 boolean evenPersistent, boolean uninstalling, int userId, String reason) { 5640 int i; 5641 5642 if (userId == UserHandle.USER_ALL && packageName == null) { 5643 Slog.w(TAG, "Can't force stop all processes of all users, that is insane!"); 5644 } 5645 5646 if (appId < 0 && packageName != null) { 5647 try { 5648 appId = UserHandle.getAppId( 5649 AppGlobals.getPackageManager().getPackageUid(packageName, 0)); 5650 } catch (RemoteException e) { 5651 } 5652 } 5653 5654 if (doit) { 5655 if (packageName != null) { 5656 Slog.i(TAG, "Force stopping " + packageName + " appid=" + appId 5657 + " user=" + userId + ": " + reason); 5658 } else { 5659 Slog.i(TAG, "Force stopping u" + userId + ": " + reason); 5660 } 5661 5662 final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap(); 5663 for (int ip = pmap.size() - 1; ip >= 0; ip--) { 5664 SparseArray<Long> ba = pmap.valueAt(ip); 5665 for (i = ba.size() - 1; i >= 0; i--) { 5666 boolean remove = false; 5667 final int entUid = ba.keyAt(i); 5668 if (packageName != null) { 5669 if (userId == UserHandle.USER_ALL) { 5670 if (UserHandle.getAppId(entUid) == appId) { 5671 remove = true; 5672 } 5673 } else { 5674 if (entUid == UserHandle.getUid(userId, appId)) { 5675 remove = true; 5676 } 5677 } 5678 } else if (UserHandle.getUserId(entUid) == userId) { 5679 remove = true; 5680 } 5681 if (remove) { 5682 ba.removeAt(i); 5683 } 5684 } 5685 if (ba.size() == 0) { 5686 pmap.removeAt(ip); 5687 } 5688 } 5689 } 5690 5691 boolean didSomething = killPackageProcessesLocked(packageName, appId, userId, 5692 -100, callerWillRestart, true, doit, evenPersistent, 5693 packageName == null ? ("stop user " + userId) : ("stop " + packageName)); 5694 5695 if (mStackSupervisor.finishDisabledPackageActivitiesLocked( 5696 packageName, null, doit, evenPersistent, userId)) { 5697 if (!doit) { 5698 return true; 5699 } 5700 didSomething = true; 5701 } 5702 5703 if (mServices.bringDownDisabledPackageServicesLocked( 5704 packageName, null, userId, evenPersistent, doit)) { 5705 if (!doit) { 5706 return true; 5707 } 5708 didSomething = true; 5709 } 5710 5711 if (packageName == null) { 5712 // Remove all sticky broadcasts from this user. 5713 mStickyBroadcasts.remove(userId); 5714 } 5715 5716 ArrayList<ContentProviderRecord> providers = new ArrayList<>(); 5717 if (mProviderMap.collectPackageProvidersLocked(packageName, null, doit, evenPersistent, 5718 userId, providers)) { 5719 if (!doit) { 5720 return true; 5721 } 5722 didSomething = true; 5723 } 5724 for (i = providers.size() - 1; i >= 0; i--) { 5725 removeDyingProviderLocked(null, providers.get(i), true); 5726 } 5727 5728 // Remove transient permissions granted from/to this package/user 5729 removeUriPermissionsForPackageLocked(packageName, userId, false); 5730 5731 if (doit) { 5732 for (i = mBroadcastQueues.length - 1; i >= 0; i--) { 5733 didSomething |= mBroadcastQueues[i].cleanupDisabledPackageReceiversLocked( 5734 packageName, null, userId, doit); 5735 } 5736 } 5737 5738 if (packageName == null || uninstalling) { 5739 // Remove pending intents. For now we only do this when force 5740 // stopping users, because we have some problems when doing this 5741 // for packages -- app widgets are not currently cleaned up for 5742 // such packages, so they can be left with bad pending intents. 5743 if (mIntentSenderRecords.size() > 0) { 5744 Iterator<WeakReference<PendingIntentRecord>> it 5745 = mIntentSenderRecords.values().iterator(); 5746 while (it.hasNext()) { 5747 WeakReference<PendingIntentRecord> wpir = it.next(); 5748 if (wpir == null) { 5749 it.remove(); 5750 continue; 5751 } 5752 PendingIntentRecord pir = wpir.get(); 5753 if (pir == null) { 5754 it.remove(); 5755 continue; 5756 } 5757 if (packageName == null) { 5758 // Stopping user, remove all objects for the user. 5759 if (pir.key.userId != userId) { 5760 // Not the same user, skip it. 5761 continue; 5762 } 5763 } else { 5764 if (UserHandle.getAppId(pir.uid) != appId) { 5765 // Different app id, skip it. 5766 continue; 5767 } 5768 if (userId != UserHandle.USER_ALL && pir.key.userId != userId) { 5769 // Different user, skip it. 5770 continue; 5771 } 5772 if (!pir.key.packageName.equals(packageName)) { 5773 // Different package, skip it. 5774 continue; 5775 } 5776 } 5777 if (!doit) { 5778 return true; 5779 } 5780 didSomething = true; 5781 it.remove(); 5782 pir.canceled = true; 5783 if (pir.key.activity != null && pir.key.activity.pendingResults != null) { 5784 pir.key.activity.pendingResults.remove(pir.ref); 5785 } 5786 } 5787 } 5788 } 5789 5790 if (doit) { 5791 if (purgeCache && packageName != null) { 5792 AttributeCache ac = AttributeCache.instance(); 5793 if (ac != null) { 5794 ac.removePackage(packageName); 5795 } 5796 } 5797 if (mBooted) { 5798 mStackSupervisor.resumeTopActivitiesLocked(); 5799 mStackSupervisor.scheduleIdleLocked(); 5800 } 5801 } 5802 5803 return didSomething; 5804 } 5805 5806 private final ProcessRecord removeProcessNameLocked(final String name, final int uid) { 5807 ProcessRecord old = mProcessNames.remove(name, uid); 5808 if (old != null) { 5809 old.uidRecord.numProcs--; 5810 if (old.uidRecord.numProcs == 0) { 5811 // No more processes using this uid, tell clients it is gone. 5812 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 5813 "No more processes in " + old.uidRecord); 5814 enqueueUidChangeLocked(old.uidRecord, true); 5815 mActiveUids.remove(uid); 5816 } 5817 old.uidRecord = null; 5818 } 5819 mIsolatedProcesses.remove(uid); 5820 return old; 5821 } 5822 5823 private final void addProcessNameLocked(ProcessRecord proc) { 5824 // We shouldn't already have a process under this name, but just in case we 5825 // need to clean up whatever may be there now. 5826 ProcessRecord old = removeProcessNameLocked(proc.processName, proc.uid); 5827 if (old == proc && proc.persistent) { 5828 // We are re-adding a persistent process. Whatevs! Just leave it there. 5829 Slog.w(TAG, "Re-adding persistent process " + proc); 5830 } else if (old != null) { 5831 Slog.wtf(TAG, "Already have existing proc " + old + " when adding " + proc); 5832 } 5833 UidRecord uidRec = mActiveUids.get(proc.uid); 5834 if (uidRec == null) { 5835 uidRec = new UidRecord(proc.uid); 5836 // This is the first appearance of the uid, report it now! 5837 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 5838 "Creating new process uid: " + uidRec); 5839 mActiveUids.put(proc.uid, uidRec); 5840 enqueueUidChangeLocked(uidRec, false); 5841 } 5842 proc.uidRecord = uidRec; 5843 uidRec.numProcs++; 5844 mProcessNames.put(proc.processName, proc.uid, proc); 5845 if (proc.isolated) { 5846 mIsolatedProcesses.put(proc.uid, proc); 5847 } 5848 } 5849 5850 private final boolean removeProcessLocked(ProcessRecord app, 5851 boolean callerWillRestart, boolean allowRestart, String reason) { 5852 final String name = app.processName; 5853 final int uid = app.uid; 5854 if (DEBUG_PROCESSES) Slog.d(TAG_PROCESSES, 5855 "Force removing proc " + app.toShortString() + " (" + name + "/" + uid + ")"); 5856 5857 removeProcessNameLocked(name, uid); 5858 if (mHeavyWeightProcess == app) { 5859 mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG, 5860 mHeavyWeightProcess.userId, 0)); 5861 mHeavyWeightProcess = null; 5862 } 5863 boolean needRestart = false; 5864 if (app.pid > 0 && app.pid != MY_PID) { 5865 int pid = app.pid; 5866 synchronized (mPidsSelfLocked) { 5867 mPidsSelfLocked.remove(pid); 5868 mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); 5869 } 5870 mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid); 5871 if (app.isolated) { 5872 mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid); 5873 } 5874 boolean willRestart = false; 5875 if (app.persistent && !app.isolated) { 5876 if (!callerWillRestart) { 5877 willRestart = true; 5878 } else { 5879 needRestart = true; 5880 } 5881 } 5882 app.kill(reason, true); 5883 handleAppDiedLocked(app, willRestart, allowRestart); 5884 if (willRestart) { 5885 removeLruProcessLocked(app); 5886 addAppLocked(app.info, false, null /* ABI override */); 5887 } 5888 } else { 5889 mRemovedProcesses.add(app); 5890 } 5891 5892 return needRestart; 5893 } 5894 5895 private final void processStartTimedOutLocked(ProcessRecord app) { 5896 final int pid = app.pid; 5897 boolean gone = false; 5898 synchronized (mPidsSelfLocked) { 5899 ProcessRecord knownApp = mPidsSelfLocked.get(pid); 5900 if (knownApp != null && knownApp.thread == null) { 5901 mPidsSelfLocked.remove(pid); 5902 gone = true; 5903 } 5904 } 5905 5906 if (gone) { 5907 Slog.w(TAG, "Process " + app + " failed to attach"); 5908 EventLog.writeEvent(EventLogTags.AM_PROCESS_START_TIMEOUT, app.userId, 5909 pid, app.uid, app.processName); 5910 removeProcessNameLocked(app.processName, app.uid); 5911 if (mHeavyWeightProcess == app) { 5912 mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG, 5913 mHeavyWeightProcess.userId, 0)); 5914 mHeavyWeightProcess = null; 5915 } 5916 mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid); 5917 if (app.isolated) { 5918 mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid); 5919 } 5920 // Take care of any launching providers waiting for this process. 5921 checkAppInLaunchingProvidersLocked(app, true); 5922 // Take care of any services that are waiting for the process. 5923 mServices.processStartTimedOutLocked(app); 5924 app.kill("start timeout", true); 5925 removeLruProcessLocked(app); 5926 if (mBackupTarget != null && mBackupTarget.app.pid == pid) { 5927 Slog.w(TAG, "Unattached app died before backup, skipping"); 5928 try { 5929 IBackupManager bm = IBackupManager.Stub.asInterface( 5930 ServiceManager.getService(Context.BACKUP_SERVICE)); 5931 bm.agentDisconnected(app.info.packageName); 5932 } catch (RemoteException e) { 5933 // Can't happen; the backup manager is local 5934 } 5935 } 5936 if (isPendingBroadcastProcessLocked(pid)) { 5937 Slog.w(TAG, "Unattached app died before broadcast acknowledged, skipping"); 5938 skipPendingBroadcastLocked(pid); 5939 } 5940 } else { 5941 Slog.w(TAG, "Spurious process start timeout - pid not known for " + app); 5942 } 5943 } 5944 5945 private final boolean attachApplicationLocked(IApplicationThread thread, 5946 int pid) { 5947 5948 // Find the application record that is being attached... either via 5949 // the pid if we are running in multiple processes, or just pull the 5950 // next app record if we are emulating process with anonymous threads. 5951 ProcessRecord app; 5952 if (pid != MY_PID && pid >= 0) { 5953 synchronized (mPidsSelfLocked) { 5954 app = mPidsSelfLocked.get(pid); 5955 } 5956 } else { 5957 app = null; 5958 } 5959 5960 if (app == null) { 5961 Slog.w(TAG, "No pending application record for pid " + pid 5962 + " (IApplicationThread " + thread + "); dropping process"); 5963 EventLog.writeEvent(EventLogTags.AM_DROP_PROCESS, pid); 5964 if (pid > 0 && pid != MY_PID) { 5965 Process.killProcessQuiet(pid); 5966 //TODO: killProcessGroup(app.info.uid, pid); 5967 } else { 5968 try { 5969 thread.scheduleExit(); 5970 } catch (Exception e) { 5971 // Ignore exceptions. 5972 } 5973 } 5974 return false; 5975 } 5976 5977 // If this application record is still attached to a previous 5978 // process, clean it up now. 5979 if (app.thread != null) { 5980 handleAppDiedLocked(app, true, true); 5981 } 5982 5983 // Tell the process all about itself. 5984 5985 if (DEBUG_ALL) Slog.v( 5986 TAG, "Binding process pid " + pid + " to record " + app); 5987 5988 final String processName = app.processName; 5989 try { 5990 AppDeathRecipient adr = new AppDeathRecipient( 5991 app, pid, thread); 5992 thread.asBinder().linkToDeath(adr, 0); 5993 app.deathRecipient = adr; 5994 } catch (RemoteException e) { 5995 app.resetPackageList(mProcessStats); 5996 startProcessLocked(app, "link fail", processName); 5997 return false; 5998 } 5999 6000 EventLog.writeEvent(EventLogTags.AM_PROC_BOUND, app.userId, app.pid, app.processName); 6001 6002 app.makeActive(thread, mProcessStats); 6003 app.curAdj = app.setAdj = -100; 6004 app.curSchedGroup = app.setSchedGroup = Process.THREAD_GROUP_DEFAULT; 6005 app.forcingToForeground = null; 6006 updateProcessForegroundLocked(app, false, false); 6007 app.hasShownUi = false; 6008 app.debugging = false; 6009 app.cached = false; 6010 app.killedByAm = false; 6011 6012 mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); 6013 6014 boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info); 6015 List<ProviderInfo> providers = normalMode ? generateApplicationProvidersLocked(app) : null; 6016 6017 if (!normalMode) { 6018 Slog.i(TAG, "Launching preboot mode app: " + app); 6019 } 6020 6021 if (DEBUG_ALL) Slog.v( 6022 TAG, "New app record " + app 6023 + " thread=" + thread.asBinder() + " pid=" + pid); 6024 try { 6025 int testMode = IApplicationThread.DEBUG_OFF; 6026 if (mDebugApp != null && mDebugApp.equals(processName)) { 6027 testMode = mWaitForDebugger 6028 ? IApplicationThread.DEBUG_WAIT 6029 : IApplicationThread.DEBUG_ON; 6030 app.debugging = true; 6031 if (mDebugTransient) { 6032 mDebugApp = mOrigDebugApp; 6033 mWaitForDebugger = mOrigWaitForDebugger; 6034 } 6035 } 6036 String profileFile = app.instrumentationProfileFile; 6037 ParcelFileDescriptor profileFd = null; 6038 int samplingInterval = 0; 6039 boolean profileAutoStop = false; 6040 if (mProfileApp != null && mProfileApp.equals(processName)) { 6041 mProfileProc = app; 6042 profileFile = mProfileFile; 6043 profileFd = mProfileFd; 6044 samplingInterval = mSamplingInterval; 6045 profileAutoStop = mAutoStopProfiler; 6046 } 6047 boolean enableOpenGlTrace = false; 6048 if (mOpenGlTraceApp != null && mOpenGlTraceApp.equals(processName)) { 6049 enableOpenGlTrace = true; 6050 mOpenGlTraceApp = null; 6051 } 6052 boolean enableTrackAllocation = false; 6053 if (mTrackAllocationApp != null && mTrackAllocationApp.equals(processName)) { 6054 enableTrackAllocation = true; 6055 mTrackAllocationApp = null; 6056 } 6057 6058 // If the app is being launched for restore or full backup, set it up specially 6059 boolean isRestrictedBackupMode = false; 6060 if (mBackupTarget != null && mBackupAppName.equals(processName)) { 6061 isRestrictedBackupMode = (mBackupTarget.backupMode == BackupRecord.RESTORE) 6062 || (mBackupTarget.backupMode == BackupRecord.RESTORE_FULL) 6063 || (mBackupTarget.backupMode == BackupRecord.BACKUP_FULL); 6064 } 6065 6066 ensurePackageDexOpt(app.instrumentationInfo != null 6067 ? app.instrumentationInfo.packageName 6068 : app.info.packageName); 6069 if (app.instrumentationClass != null) { 6070 ensurePackageDexOpt(app.instrumentationClass.getPackageName()); 6071 } 6072 if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Binding proc " 6073 + processName + " with config " + mConfiguration); 6074 ApplicationInfo appInfo = app.instrumentationInfo != null 6075 ? app.instrumentationInfo : app.info; 6076 app.compat = compatibilityInfoForPackageLocked(appInfo); 6077 if (profileFd != null) { 6078 profileFd = profileFd.dup(); 6079 } 6080 ProfilerInfo profilerInfo = profileFile == null ? null 6081 : new ProfilerInfo(profileFile, profileFd, samplingInterval, profileAutoStop); 6082 thread.bindApplication(processName, appInfo, providers, app.instrumentationClass, 6083 profilerInfo, app.instrumentationArguments, app.instrumentationWatcher, 6084 app.instrumentationUiAutomationConnection, testMode, enableOpenGlTrace, 6085 enableTrackAllocation, isRestrictedBackupMode || !normalMode, app.persistent, 6086 new Configuration(mConfiguration), app.compat, 6087 getCommonServicesLocked(app.isolated), 6088 mCoreSettingsObserver.getCoreSettingsLocked()); 6089 updateLruProcessLocked(app, false, null); 6090 app.lastRequestedGc = app.lastLowMemory = SystemClock.uptimeMillis(); 6091 } catch (Exception e) { 6092 // todo: Yikes! What should we do? For now we will try to 6093 // start another process, but that could easily get us in 6094 // an infinite loop of restarting processes... 6095 Slog.wtf(TAG, "Exception thrown during bind of " + app, e); 6096 6097 app.resetPackageList(mProcessStats); 6098 app.unlinkDeathRecipient(); 6099 startProcessLocked(app, "bind fail", processName); 6100 return false; 6101 } 6102 6103 // Remove this record from the list of starting applications. 6104 mPersistentStartingProcesses.remove(app); 6105 if (DEBUG_PROCESSES && mProcessesOnHold.contains(app)) Slog.v(TAG_PROCESSES, 6106 "Attach application locked removing on hold: " + app); 6107 mProcessesOnHold.remove(app); 6108 6109 boolean badApp = false; 6110 boolean didSomething = false; 6111 6112 // See if the top visible activity is waiting to run in this process... 6113 if (normalMode) { 6114 try { 6115 if (mStackSupervisor.attachApplicationLocked(app)) { 6116 didSomething = true; 6117 } 6118 } catch (Exception e) { 6119 Slog.wtf(TAG, "Exception thrown launching activities in " + app, e); 6120 badApp = true; 6121 } 6122 } 6123 6124 // Find any services that should be running in this process... 6125 if (!badApp) { 6126 try { 6127 didSomething |= mServices.attachApplicationLocked(app, processName); 6128 } catch (Exception e) { 6129 Slog.wtf(TAG, "Exception thrown starting services in " + app, e); 6130 badApp = true; 6131 } 6132 } 6133 6134 // Check if a next-broadcast receiver is in this process... 6135 if (!badApp && isPendingBroadcastProcessLocked(pid)) { 6136 try { 6137 didSomething |= sendPendingBroadcastsLocked(app); 6138 } catch (Exception e) { 6139 // If the app died trying to launch the receiver we declare it 'bad' 6140 Slog.wtf(TAG, "Exception thrown dispatching broadcasts in " + app, e); 6141 badApp = true; 6142 } 6143 } 6144 6145 // Check whether the next backup agent is in this process... 6146 if (!badApp && mBackupTarget != null && mBackupTarget.appInfo.uid == app.uid) { 6147 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, 6148 "New app is backup target, launching agent for " + app); 6149 ensurePackageDexOpt(mBackupTarget.appInfo.packageName); 6150 try { 6151 thread.scheduleCreateBackupAgent(mBackupTarget.appInfo, 6152 compatibilityInfoForPackageLocked(mBackupTarget.appInfo), 6153 mBackupTarget.backupMode); 6154 } catch (Exception e) { 6155 Slog.wtf(TAG, "Exception thrown creating backup agent in " + app, e); 6156 badApp = true; 6157 } 6158 } 6159 6160 if (badApp) { 6161 app.kill("error during init", true); 6162 handleAppDiedLocked(app, false, true); 6163 return false; 6164 } 6165 6166 if (!didSomething) { 6167 updateOomAdjLocked(); 6168 } 6169 6170 return true; 6171 } 6172 6173 @Override 6174 public final void attachApplication(IApplicationThread thread) { 6175 synchronized (this) { 6176 int callingPid = Binder.getCallingPid(); 6177 final long origId = Binder.clearCallingIdentity(); 6178 attachApplicationLocked(thread, callingPid); 6179 Binder.restoreCallingIdentity(origId); 6180 } 6181 } 6182 6183 @Override 6184 public final void activityIdle(IBinder token, Configuration config, boolean stopProfiling) { 6185 final long origId = Binder.clearCallingIdentity(); 6186 synchronized (this) { 6187 ActivityStack stack = ActivityRecord.getStackLocked(token); 6188 if (stack != null) { 6189 ActivityRecord r = 6190 mStackSupervisor.activityIdleInternalLocked(token, false, config); 6191 if (stopProfiling) { 6192 if ((mProfileProc == r.app) && (mProfileFd != null)) { 6193 try { 6194 mProfileFd.close(); 6195 } catch (IOException e) { 6196 } 6197 clearProfilerLocked(); 6198 } 6199 } 6200 } 6201 } 6202 Binder.restoreCallingIdentity(origId); 6203 } 6204 6205 void postFinishBooting(boolean finishBooting, boolean enableScreen) { 6206 mHandler.sendMessage(mHandler.obtainMessage(FINISH_BOOTING_MSG, 6207 finishBooting ? 1 : 0, enableScreen ? 1 : 0)); 6208 } 6209 6210 void enableScreenAfterBoot() { 6211 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_ENABLE_SCREEN, 6212 SystemClock.uptimeMillis()); 6213 mWindowManager.enableScreenAfterBoot(); 6214 6215 synchronized (this) { 6216 updateEventDispatchingLocked(); 6217 } 6218 } 6219 6220 @Override 6221 public void showBootMessage(final CharSequence msg, final boolean always) { 6222 if (Binder.getCallingUid() != Process.myUid()) { 6223 // These days only the core system can call this, so apps can't get in 6224 // the way of what we show about running them. 6225 } 6226 mWindowManager.showBootMessage(msg, always); 6227 } 6228 6229 @Override 6230 public void keyguardWaitingForActivityDrawn() { 6231 enforceNotIsolatedCaller("keyguardWaitingForActivityDrawn"); 6232 final long token = Binder.clearCallingIdentity(); 6233 try { 6234 synchronized (this) { 6235 if (DEBUG_LOCKSCREEN) logLockScreen(""); 6236 mWindowManager.keyguardWaitingForActivityDrawn(); 6237 if (mLockScreenShown == LOCK_SCREEN_SHOWN) { 6238 mLockScreenShown = LOCK_SCREEN_LEAVING; 6239 updateSleepIfNeededLocked(); 6240 } 6241 } 6242 } finally { 6243 Binder.restoreCallingIdentity(token); 6244 } 6245 } 6246 6247 @Override 6248 public void keyguardGoingAway(boolean disableWindowAnimations, 6249 boolean keyguardGoingToNotificationShade) { 6250 enforceNotIsolatedCaller("keyguardGoingAway"); 6251 final long token = Binder.clearCallingIdentity(); 6252 try { 6253 synchronized (this) { 6254 if (DEBUG_LOCKSCREEN) logLockScreen(""); 6255 mWindowManager.keyguardGoingAway(disableWindowAnimations, 6256 keyguardGoingToNotificationShade); 6257 if (mLockScreenShown == LOCK_SCREEN_SHOWN) { 6258 mLockScreenShown = LOCK_SCREEN_HIDDEN; 6259 updateSleepIfNeededLocked(); 6260 } 6261 } 6262 } finally { 6263 Binder.restoreCallingIdentity(token); 6264 } 6265 } 6266 6267 final void finishBooting() { 6268 synchronized (this) { 6269 if (!mBootAnimationComplete) { 6270 mCallFinishBooting = true; 6271 return; 6272 } 6273 mCallFinishBooting = false; 6274 } 6275 6276 ArraySet<String> completedIsas = new ArraySet<String>(); 6277 for (String abi : Build.SUPPORTED_ABIS) { 6278 Process.establishZygoteConnectionForAbi(abi); 6279 final String instructionSet = VMRuntime.getInstructionSet(abi); 6280 if (!completedIsas.contains(instructionSet)) { 6281 if (mInstaller.markBootComplete(VMRuntime.getInstructionSet(abi)) != 0) { 6282 Slog.e(TAG, "Unable to mark boot complete for abi: " + abi); 6283 } 6284 completedIsas.add(instructionSet); 6285 } 6286 } 6287 6288 IntentFilter pkgFilter = new IntentFilter(); 6289 pkgFilter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART); 6290 pkgFilter.addDataScheme("package"); 6291 mContext.registerReceiver(new BroadcastReceiver() { 6292 @Override 6293 public void onReceive(Context context, Intent intent) { 6294 String[] pkgs = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES); 6295 if (pkgs != null) { 6296 for (String pkg : pkgs) { 6297 synchronized (ActivityManagerService.this) { 6298 if (forceStopPackageLocked(pkg, -1, false, false, false, false, false, 6299 0, "query restart")) { 6300 setResultCode(Activity.RESULT_OK); 6301 return; 6302 } 6303 } 6304 } 6305 } 6306 } 6307 }, pkgFilter); 6308 6309 IntentFilter dumpheapFilter = new IntentFilter(); 6310 dumpheapFilter.addAction(DumpHeapActivity.ACTION_DELETE_DUMPHEAP); 6311 mContext.registerReceiver(new BroadcastReceiver() { 6312 @Override 6313 public void onReceive(Context context, Intent intent) { 6314 if (intent.getBooleanExtra(DumpHeapActivity.EXTRA_DELAY_DELETE, false)) { 6315 mHandler.sendEmptyMessageDelayed(POST_DUMP_HEAP_NOTIFICATION_MSG, 5*60*1000); 6316 } else { 6317 mHandler.sendEmptyMessage(POST_DUMP_HEAP_NOTIFICATION_MSG); 6318 } 6319 } 6320 }, dumpheapFilter); 6321 6322 // Let system services know. 6323 mSystemServiceManager.startBootPhase(SystemService.PHASE_BOOT_COMPLETED); 6324 6325 synchronized (this) { 6326 // Ensure that any processes we had put on hold are now started 6327 // up. 6328 final int NP = mProcessesOnHold.size(); 6329 if (NP > 0) { 6330 ArrayList<ProcessRecord> procs = 6331 new ArrayList<ProcessRecord>(mProcessesOnHold); 6332 for (int ip=0; ip<NP; ip++) { 6333 if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "Starting process on hold: " 6334 + procs.get(ip)); 6335 startProcessLocked(procs.get(ip), "on-hold", null); 6336 } 6337 } 6338 6339 if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) { 6340 // Start looking for apps that are abusing wake locks. 6341 Message nmsg = mHandler.obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG); 6342 mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY); 6343 // Tell anyone interested that we are done booting! 6344 SystemProperties.set("sys.boot_completed", "1"); 6345 6346 // And trigger dev.bootcomplete if we are not showing encryption progress 6347 if (!"trigger_restart_min_framework".equals(SystemProperties.get("vold.decrypt")) 6348 || "".equals(SystemProperties.get("vold.encrypt_progress"))) { 6349 SystemProperties.set("dev.bootcomplete", "1"); 6350 } 6351 for (int i=0; i<mStartedUsers.size(); i++) { 6352 UserState uss = mStartedUsers.valueAt(i); 6353 if (uss.mState == UserState.STATE_BOOTING) { 6354 uss.mState = UserState.STATE_RUNNING; 6355 final int userId = mStartedUsers.keyAt(i); 6356 Intent intent = new Intent(Intent.ACTION_BOOT_COMPLETED, null); 6357 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 6358 intent.addFlags(Intent.FLAG_RECEIVER_NO_ABORT); 6359 broadcastIntentLocked(null, null, intent, null, 6360 new IIntentReceiver.Stub() { 6361 @Override 6362 public void performReceive(Intent intent, int resultCode, 6363 String data, Bundle extras, boolean ordered, 6364 boolean sticky, int sendingUser) { 6365 synchronized (ActivityManagerService.this) { 6366 requestPssAllProcsLocked(SystemClock.uptimeMillis(), 6367 true, false); 6368 } 6369 } 6370 }, 6371 0, null, null, 6372 new String[] {android.Manifest.permission.RECEIVE_BOOT_COMPLETED}, 6373 AppOpsManager.OP_NONE, null, true, false, 6374 MY_PID, Process.SYSTEM_UID, userId); 6375 } 6376 } 6377 scheduleStartProfilesLocked(); 6378 } 6379 } 6380 } 6381 6382 @Override 6383 public void bootAnimationComplete() { 6384 final boolean callFinishBooting; 6385 synchronized (this) { 6386 callFinishBooting = mCallFinishBooting; 6387 mBootAnimationComplete = true; 6388 } 6389 if (callFinishBooting) { 6390 finishBooting(); 6391 } 6392 } 6393 6394 final void ensureBootCompleted() { 6395 boolean booting; 6396 boolean enableScreen; 6397 synchronized (this) { 6398 booting = mBooting; 6399 mBooting = false; 6400 enableScreen = !mBooted; 6401 mBooted = true; 6402 } 6403 6404 if (booting) { 6405 finishBooting(); 6406 } 6407 6408 if (enableScreen) { 6409 enableScreenAfterBoot(); 6410 } 6411 } 6412 6413 @Override 6414 public final void activityResumed(IBinder token) { 6415 final long origId = Binder.clearCallingIdentity(); 6416 synchronized(this) { 6417 ActivityStack stack = ActivityRecord.getStackLocked(token); 6418 if (stack != null) { 6419 ActivityRecord.activityResumedLocked(token); 6420 } 6421 } 6422 Binder.restoreCallingIdentity(origId); 6423 } 6424 6425 @Override 6426 public final void activityPaused(IBinder token) { 6427 final long origId = Binder.clearCallingIdentity(); 6428 synchronized(this) { 6429 ActivityStack stack = ActivityRecord.getStackLocked(token); 6430 if (stack != null) { 6431 stack.activityPausedLocked(token, false); 6432 } 6433 } 6434 Binder.restoreCallingIdentity(origId); 6435 } 6436 6437 @Override 6438 public final void activityStopped(IBinder token, Bundle icicle, 6439 PersistableBundle persistentState, CharSequence description) { 6440 if (DEBUG_ALL) Slog.v(TAG, "Activity stopped: token=" + token); 6441 6442 // Refuse possible leaked file descriptors 6443 if (icicle != null && icicle.hasFileDescriptors()) { 6444 throw new IllegalArgumentException("File descriptors passed in Bundle"); 6445 } 6446 6447 final long origId = Binder.clearCallingIdentity(); 6448 6449 synchronized (this) { 6450 ActivityRecord r = ActivityRecord.isInStackLocked(token); 6451 if (r != null) { 6452 r.task.stack.activityStoppedLocked(r, icicle, persistentState, description); 6453 } 6454 } 6455 6456 trimApplications(); 6457 6458 Binder.restoreCallingIdentity(origId); 6459 } 6460 6461 @Override 6462 public final void activityDestroyed(IBinder token) { 6463 if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "ACTIVITY DESTROYED: " + token); 6464 synchronized (this) { 6465 ActivityStack stack = ActivityRecord.getStackLocked(token); 6466 if (stack != null) { 6467 stack.activityDestroyedLocked(token, "activityDestroyed"); 6468 } 6469 } 6470 } 6471 6472 @Override 6473 public final void backgroundResourcesReleased(IBinder token) { 6474 final long origId = Binder.clearCallingIdentity(); 6475 try { 6476 synchronized (this) { 6477 ActivityStack stack = ActivityRecord.getStackLocked(token); 6478 if (stack != null) { 6479 stack.backgroundResourcesReleased(); 6480 } 6481 } 6482 } finally { 6483 Binder.restoreCallingIdentity(origId); 6484 } 6485 } 6486 6487 @Override 6488 public final void notifyLaunchTaskBehindComplete(IBinder token) { 6489 mStackSupervisor.scheduleLaunchTaskBehindComplete(token); 6490 } 6491 6492 @Override 6493 public final void notifyEnterAnimationComplete(IBinder token) { 6494 mHandler.sendMessage(mHandler.obtainMessage(ENTER_ANIMATION_COMPLETE_MSG, token)); 6495 } 6496 6497 @Override 6498 public String getCallingPackage(IBinder token) { 6499 synchronized (this) { 6500 ActivityRecord r = getCallingRecordLocked(token); 6501 return r != null ? r.info.packageName : null; 6502 } 6503 } 6504 6505 @Override 6506 public ComponentName getCallingActivity(IBinder token) { 6507 synchronized (this) { 6508 ActivityRecord r = getCallingRecordLocked(token); 6509 return r != null ? r.intent.getComponent() : null; 6510 } 6511 } 6512 6513 private ActivityRecord getCallingRecordLocked(IBinder token) { 6514 ActivityRecord r = ActivityRecord.isInStackLocked(token); 6515 if (r == null) { 6516 return null; 6517 } 6518 return r.resultTo; 6519 } 6520 6521 @Override 6522 public ComponentName getActivityClassForToken(IBinder token) { 6523 synchronized(this) { 6524 ActivityRecord r = ActivityRecord.isInStackLocked(token); 6525 if (r == null) { 6526 return null; 6527 } 6528 return r.intent.getComponent(); 6529 } 6530 } 6531 6532 @Override 6533 public String getPackageForToken(IBinder token) { 6534 synchronized(this) { 6535 ActivityRecord r = ActivityRecord.isInStackLocked(token); 6536 if (r == null) { 6537 return null; 6538 } 6539 return r.packageName; 6540 } 6541 } 6542 6543 @Override 6544 public boolean isRootVoiceInteraction(IBinder token) { 6545 synchronized(this) { 6546 ActivityRecord r = ActivityRecord.isInStackLocked(token); 6547 if (r == null) { 6548 return false; 6549 } 6550 return r.rootVoiceInteraction; 6551 } 6552 } 6553 6554 @Override 6555 public IIntentSender getIntentSender(int type, 6556 String packageName, IBinder token, String resultWho, 6557 int requestCode, Intent[] intents, String[] resolvedTypes, 6558 int flags, Bundle options, int userId) { 6559 enforceNotIsolatedCaller("getIntentSender"); 6560 // Refuse possible leaked file descriptors 6561 if (intents != null) { 6562 if (intents.length < 1) { 6563 throw new IllegalArgumentException("Intents array length must be >= 1"); 6564 } 6565 for (int i=0; i<intents.length; i++) { 6566 Intent intent = intents[i]; 6567 if (intent != null) { 6568 if (intent.hasFileDescriptors()) { 6569 throw new IllegalArgumentException("File descriptors passed in Intent"); 6570 } 6571 if (type == ActivityManager.INTENT_SENDER_BROADCAST && 6572 (intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0) { 6573 throw new IllegalArgumentException( 6574 "Can't use FLAG_RECEIVER_BOOT_UPGRADE here"); 6575 } 6576 intents[i] = new Intent(intent); 6577 } 6578 } 6579 if (resolvedTypes != null && resolvedTypes.length != intents.length) { 6580 throw new IllegalArgumentException( 6581 "Intent array length does not match resolvedTypes length"); 6582 } 6583 } 6584 if (options != null) { 6585 if (options.hasFileDescriptors()) { 6586 throw new IllegalArgumentException("File descriptors passed in options"); 6587 } 6588 } 6589 6590 synchronized(this) { 6591 int callingUid = Binder.getCallingUid(); 6592 int origUserId = userId; 6593 userId = handleIncomingUser(Binder.getCallingPid(), callingUid, userId, 6594 type == ActivityManager.INTENT_SENDER_BROADCAST, 6595 ALLOW_NON_FULL, "getIntentSender", null); 6596 if (origUserId == UserHandle.USER_CURRENT) { 6597 // We don't want to evaluate this until the pending intent is 6598 // actually executed. However, we do want to always do the 6599 // security checking for it above. 6600 userId = UserHandle.USER_CURRENT; 6601 } 6602 try { 6603 if (callingUid != 0 && callingUid != Process.SYSTEM_UID) { 6604 int uid = AppGlobals.getPackageManager() 6605 .getPackageUid(packageName, UserHandle.getUserId(callingUid)); 6606 if (!UserHandle.isSameApp(callingUid, uid)) { 6607 String msg = "Permission Denial: getIntentSender() from pid=" 6608 + Binder.getCallingPid() 6609 + ", uid=" + Binder.getCallingUid() 6610 + ", (need uid=" + uid + ")" 6611 + " is not allowed to send as package " + packageName; 6612 Slog.w(TAG, msg); 6613 throw new SecurityException(msg); 6614 } 6615 } 6616 6617 return getIntentSenderLocked(type, packageName, callingUid, userId, 6618 token, resultWho, requestCode, intents, resolvedTypes, flags, options); 6619 6620 } catch (RemoteException e) { 6621 throw new SecurityException(e); 6622 } 6623 } 6624 } 6625 6626 IIntentSender getIntentSenderLocked(int type, String packageName, 6627 int callingUid, int userId, IBinder token, String resultWho, 6628 int requestCode, Intent[] intents, String[] resolvedTypes, int flags, 6629 Bundle options) { 6630 if (DEBUG_MU) Slog.v(TAG_MU, "getIntentSenderLocked(): uid=" + callingUid); 6631 ActivityRecord activity = null; 6632 if (type == ActivityManager.INTENT_SENDER_ACTIVITY_RESULT) { 6633 activity = ActivityRecord.isInStackLocked(token); 6634 if (activity == null) { 6635 return null; 6636 } 6637 if (activity.finishing) { 6638 return null; 6639 } 6640 } 6641 6642 final boolean noCreate = (flags&PendingIntent.FLAG_NO_CREATE) != 0; 6643 final boolean cancelCurrent = (flags&PendingIntent.FLAG_CANCEL_CURRENT) != 0; 6644 final boolean updateCurrent = (flags&PendingIntent.FLAG_UPDATE_CURRENT) != 0; 6645 flags &= ~(PendingIntent.FLAG_NO_CREATE|PendingIntent.FLAG_CANCEL_CURRENT 6646 |PendingIntent.FLAG_UPDATE_CURRENT); 6647 6648 PendingIntentRecord.Key key = new PendingIntentRecord.Key( 6649 type, packageName, activity, resultWho, 6650 requestCode, intents, resolvedTypes, flags, options, userId); 6651 WeakReference<PendingIntentRecord> ref; 6652 ref = mIntentSenderRecords.get(key); 6653 PendingIntentRecord rec = ref != null ? ref.get() : null; 6654 if (rec != null) { 6655 if (!cancelCurrent) { 6656 if (updateCurrent) { 6657 if (rec.key.requestIntent != null) { 6658 rec.key.requestIntent.replaceExtras(intents != null ? 6659 intents[intents.length - 1] : null); 6660 } 6661 if (intents != null) { 6662 intents[intents.length-1] = rec.key.requestIntent; 6663 rec.key.allIntents = intents; 6664 rec.key.allResolvedTypes = resolvedTypes; 6665 } else { 6666 rec.key.allIntents = null; 6667 rec.key.allResolvedTypes = null; 6668 } 6669 } 6670 return rec; 6671 } 6672 rec.canceled = true; 6673 mIntentSenderRecords.remove(key); 6674 } 6675 if (noCreate) { 6676 return rec; 6677 } 6678 rec = new PendingIntentRecord(this, key, callingUid); 6679 mIntentSenderRecords.put(key, rec.ref); 6680 if (type == ActivityManager.INTENT_SENDER_ACTIVITY_RESULT) { 6681 if (activity.pendingResults == null) { 6682 activity.pendingResults 6683 = new HashSet<WeakReference<PendingIntentRecord>>(); 6684 } 6685 activity.pendingResults.add(rec.ref); 6686 } 6687 return rec; 6688 } 6689 6690 @Override 6691 public void cancelIntentSender(IIntentSender sender) { 6692 if (!(sender instanceof PendingIntentRecord)) { 6693 return; 6694 } 6695 synchronized(this) { 6696 PendingIntentRecord rec = (PendingIntentRecord)sender; 6697 try { 6698 int uid = AppGlobals.getPackageManager() 6699 .getPackageUid(rec.key.packageName, UserHandle.getCallingUserId()); 6700 if (!UserHandle.isSameApp(uid, Binder.getCallingUid())) { 6701 String msg = "Permission Denial: cancelIntentSender() from pid=" 6702 + Binder.getCallingPid() 6703 + ", uid=" + Binder.getCallingUid() 6704 + " is not allowed to cancel packges " 6705 + rec.key.packageName; 6706 Slog.w(TAG, msg); 6707 throw new SecurityException(msg); 6708 } 6709 } catch (RemoteException e) { 6710 throw new SecurityException(e); 6711 } 6712 cancelIntentSenderLocked(rec, true); 6713 } 6714 } 6715 6716 void cancelIntentSenderLocked(PendingIntentRecord rec, boolean cleanActivity) { 6717 rec.canceled = true; 6718 mIntentSenderRecords.remove(rec.key); 6719 if (cleanActivity && rec.key.activity != null) { 6720 rec.key.activity.pendingResults.remove(rec.ref); 6721 } 6722 } 6723 6724 @Override 6725 public String getPackageForIntentSender(IIntentSender pendingResult) { 6726 if (!(pendingResult instanceof PendingIntentRecord)) { 6727 return null; 6728 } 6729 try { 6730 PendingIntentRecord res = (PendingIntentRecord)pendingResult; 6731 return res.key.packageName; 6732 } catch (ClassCastException e) { 6733 } 6734 return null; 6735 } 6736 6737 @Override 6738 public int getUidForIntentSender(IIntentSender sender) { 6739 if (sender instanceof PendingIntentRecord) { 6740 try { 6741 PendingIntentRecord res = (PendingIntentRecord)sender; 6742 return res.uid; 6743 } catch (ClassCastException e) { 6744 } 6745 } 6746 return -1; 6747 } 6748 6749 @Override 6750 public boolean isIntentSenderTargetedToPackage(IIntentSender pendingResult) { 6751 if (!(pendingResult instanceof PendingIntentRecord)) { 6752 return false; 6753 } 6754 try { 6755 PendingIntentRecord res = (PendingIntentRecord)pendingResult; 6756 if (res.key.allIntents == null) { 6757 return false; 6758 } 6759 for (int i=0; i<res.key.allIntents.length; i++) { 6760 Intent intent = res.key.allIntents[i]; 6761 if (intent.getPackage() != null && intent.getComponent() != null) { 6762 return false; 6763 } 6764 } 6765 return true; 6766 } catch (ClassCastException e) { 6767 } 6768 return false; 6769 } 6770 6771 @Override 6772 public boolean isIntentSenderAnActivity(IIntentSender pendingResult) { 6773 if (!(pendingResult instanceof PendingIntentRecord)) { 6774 return false; 6775 } 6776 try { 6777 PendingIntentRecord res = (PendingIntentRecord)pendingResult; 6778 if (res.key.type == ActivityManager.INTENT_SENDER_ACTIVITY) { 6779 return true; 6780 } 6781 return false; 6782 } catch (ClassCastException e) { 6783 } 6784 return false; 6785 } 6786 6787 @Override 6788 public Intent getIntentForIntentSender(IIntentSender pendingResult) { 6789 if (!(pendingResult instanceof PendingIntentRecord)) { 6790 return null; 6791 } 6792 try { 6793 PendingIntentRecord res = (PendingIntentRecord)pendingResult; 6794 return res.key.requestIntent != null ? new Intent(res.key.requestIntent) : null; 6795 } catch (ClassCastException e) { 6796 } 6797 return null; 6798 } 6799 6800 @Override 6801 public String getTagForIntentSender(IIntentSender pendingResult, String prefix) { 6802 if (!(pendingResult instanceof PendingIntentRecord)) { 6803 return null; 6804 } 6805 try { 6806 PendingIntentRecord res = (PendingIntentRecord)pendingResult; 6807 synchronized (this) { 6808 return getTagForIntentSenderLocked(res, prefix); 6809 } 6810 } catch (ClassCastException e) { 6811 } 6812 return null; 6813 } 6814 6815 String getTagForIntentSenderLocked(PendingIntentRecord res, String prefix) { 6816 final Intent intent = res.key.requestIntent; 6817 if (intent != null) { 6818 if (res.lastTag != null && res.lastTagPrefix == prefix && (res.lastTagPrefix == null 6819 || res.lastTagPrefix.equals(prefix))) { 6820 return res.lastTag; 6821 } 6822 res.lastTagPrefix = prefix; 6823 final StringBuilder sb = new StringBuilder(128); 6824 if (prefix != null) { 6825 sb.append(prefix); 6826 } 6827 if (intent.getAction() != null) { 6828 sb.append(intent.getAction()); 6829 } else if (intent.getComponent() != null) { 6830 intent.getComponent().appendShortString(sb); 6831 } else { 6832 sb.append("?"); 6833 } 6834 return res.lastTag = sb.toString(); 6835 } 6836 return null; 6837 } 6838 6839 @Override 6840 public void setProcessLimit(int max) { 6841 enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, 6842 "setProcessLimit()"); 6843 synchronized (this) { 6844 mProcessLimit = max < 0 ? ProcessList.MAX_CACHED_APPS : max; 6845 mProcessLimitOverride = max; 6846 } 6847 trimApplications(); 6848 } 6849 6850 @Override 6851 public int getProcessLimit() { 6852 synchronized (this) { 6853 return mProcessLimitOverride; 6854 } 6855 } 6856 6857 void foregroundTokenDied(ForegroundToken token) { 6858 synchronized (ActivityManagerService.this) { 6859 synchronized (mPidsSelfLocked) { 6860 ForegroundToken cur 6861 = mForegroundProcesses.get(token.pid); 6862 if (cur != token) { 6863 return; 6864 } 6865 mForegroundProcesses.remove(token.pid); 6866 ProcessRecord pr = mPidsSelfLocked.get(token.pid); 6867 if (pr == null) { 6868 return; 6869 } 6870 pr.forcingToForeground = null; 6871 updateProcessForegroundLocked(pr, false, false); 6872 } 6873 updateOomAdjLocked(); 6874 } 6875 } 6876 6877 @Override 6878 public void setProcessForeground(IBinder token, int pid, boolean isForeground) { 6879 enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, 6880 "setProcessForeground()"); 6881 synchronized(this) { 6882 boolean changed = false; 6883 6884 synchronized (mPidsSelfLocked) { 6885 ProcessRecord pr = mPidsSelfLocked.get(pid); 6886 if (pr == null && isForeground) { 6887 Slog.w(TAG, "setProcessForeground called on unknown pid: " + pid); 6888 return; 6889 } 6890 ForegroundToken oldToken = mForegroundProcesses.get(pid); 6891 if (oldToken != null) { 6892 oldToken.token.unlinkToDeath(oldToken, 0); 6893 mForegroundProcesses.remove(pid); 6894 if (pr != null) { 6895 pr.forcingToForeground = null; 6896 } 6897 changed = true; 6898 } 6899 if (isForeground && token != null) { 6900 ForegroundToken newToken = new ForegroundToken() { 6901 @Override 6902 public void binderDied() { 6903 foregroundTokenDied(this); 6904 } 6905 }; 6906 newToken.pid = pid; 6907 newToken.token = token; 6908 try { 6909 token.linkToDeath(newToken, 0); 6910 mForegroundProcesses.put(pid, newToken); 6911 pr.forcingToForeground = token; 6912 changed = true; 6913 } catch (RemoteException e) { 6914 // If the process died while doing this, we will later 6915 // do the cleanup with the process death link. 6916 } 6917 } 6918 } 6919 6920 if (changed) { 6921 updateOomAdjLocked(); 6922 } 6923 } 6924 } 6925 6926 // ========================================================= 6927 // PROCESS INFO 6928 // ========================================================= 6929 6930 static class ProcessInfoService extends IProcessInfoService.Stub { 6931 final ActivityManagerService mActivityManagerService; 6932 ProcessInfoService(ActivityManagerService activityManagerService) { 6933 mActivityManagerService = activityManagerService; 6934 } 6935 6936 @Override 6937 public void getProcessStatesFromPids(/*in*/ int[] pids, /*out*/ int[] states) { 6938 mActivityManagerService.getProcessStatesForPIDs(/*in*/ pids, /*out*/ states); 6939 } 6940 } 6941 6942 /** 6943 * For each PID in the given input array, write the current process state 6944 * for that process into the output array, or -1 to indicate that no 6945 * process with the given PID exists. 6946 */ 6947 public void getProcessStatesForPIDs(/*in*/ int[] pids, /*out*/ int[] states) { 6948 if (pids == null) { 6949 throw new NullPointerException("pids"); 6950 } else if (states == null) { 6951 throw new NullPointerException("states"); 6952 } else if (pids.length != states.length) { 6953 throw new IllegalArgumentException("input and output arrays have different lengths!"); 6954 } 6955 6956 synchronized (mPidsSelfLocked) { 6957 for (int i = 0; i < pids.length; i++) { 6958 ProcessRecord pr = mPidsSelfLocked.get(pids[i]); 6959 states[i] = (pr == null) ? ActivityManager.PROCESS_STATE_NONEXISTENT : 6960 pr.curProcState; 6961 } 6962 } 6963 } 6964 6965 // ========================================================= 6966 // PERMISSIONS 6967 // ========================================================= 6968 6969 static class PermissionController extends IPermissionController.Stub { 6970 ActivityManagerService mActivityManagerService; 6971 PermissionController(ActivityManagerService activityManagerService) { 6972 mActivityManagerService = activityManagerService; 6973 } 6974 6975 @Override 6976 public boolean checkPermission(String permission, int pid, int uid) { 6977 return mActivityManagerService.checkPermission(permission, pid, 6978 uid) == PackageManager.PERMISSION_GRANTED; 6979 } 6980 6981 @Override 6982 public String[] getPackagesForUid(int uid) { 6983 return mActivityManagerService.mContext.getPackageManager() 6984 .getPackagesForUid(uid); 6985 } 6986 6987 @Override 6988 public boolean isRuntimePermission(String permission) { 6989 try { 6990 PermissionInfo info = mActivityManagerService.mContext.getPackageManager() 6991 .getPermissionInfo(permission, 0); 6992 return info.protectionLevel == PermissionInfo.PROTECTION_DANGEROUS; 6993 } catch (NameNotFoundException nnfe) { 6994 Slog.e(TAG, "No such permission: "+ permission, nnfe); 6995 } 6996 return false; 6997 } 6998 } 6999 7000 class IntentFirewallInterface implements IntentFirewall.AMSInterface { 7001 @Override 7002 public int checkComponentPermission(String permission, int pid, int uid, 7003 int owningUid, boolean exported) { 7004 return ActivityManagerService.this.checkComponentPermission(permission, pid, uid, 7005 owningUid, exported); 7006 } 7007 7008 @Override 7009 public Object getAMSLock() { 7010 return ActivityManagerService.this; 7011 } 7012 } 7013 7014 /** 7015 * This can be called with or without the global lock held. 7016 */ 7017 int checkComponentPermission(String permission, int pid, int uid, 7018 int owningUid, boolean exported) { 7019 if (pid == MY_PID) { 7020 return PackageManager.PERMISSION_GRANTED; 7021 } 7022 return ActivityManager.checkComponentPermission(permission, uid, 7023 owningUid, exported); 7024 } 7025 7026 /** 7027 * As the only public entry point for permissions checking, this method 7028 * can enforce the semantic that requesting a check on a null global 7029 * permission is automatically denied. (Internally a null permission 7030 * string is used when calling {@link #checkComponentPermission} in cases 7031 * when only uid-based security is needed.) 7032 * 7033 * This can be called with or without the global lock held. 7034 */ 7035 @Override 7036 public int checkPermission(String permission, int pid, int uid) { 7037 if (permission == null) { 7038 return PackageManager.PERMISSION_DENIED; 7039 } 7040 return checkComponentPermission(permission, pid, uid, -1, true); 7041 } 7042 7043 @Override 7044 public int checkPermissionWithToken(String permission, int pid, int uid, IBinder callerToken) { 7045 if (permission == null) { 7046 return PackageManager.PERMISSION_DENIED; 7047 } 7048 7049 // We might be performing an operation on behalf of an indirect binder 7050 // invocation, e.g. via {@link #openContentUri}. Check and adjust the 7051 // client identity accordingly before proceeding. 7052 Identity tlsIdentity = sCallerIdentity.get(); 7053 if (tlsIdentity != null && tlsIdentity.token == callerToken) { 7054 Slog.d(TAG, "checkComponentPermission() adjusting {pid,uid} to {" 7055 + tlsIdentity.pid + "," + tlsIdentity.uid + "}"); 7056 uid = tlsIdentity.uid; 7057 pid = tlsIdentity.pid; 7058 } 7059 7060 return checkComponentPermission(permission, pid, uid, -1, true); 7061 } 7062 7063 /** 7064 * Binder IPC calls go through the public entry point. 7065 * This can be called with or without the global lock held. 7066 */ 7067 int checkCallingPermission(String permission) { 7068 return checkPermission(permission, 7069 Binder.getCallingPid(), 7070 UserHandle.getAppId(Binder.getCallingUid())); 7071 } 7072 7073 /** 7074 * This can be called with or without the global lock held. 7075 */ 7076 void enforceCallingPermission(String permission, String func) { 7077 if (checkCallingPermission(permission) 7078 == PackageManager.PERMISSION_GRANTED) { 7079 return; 7080 } 7081 7082 String msg = "Permission Denial: " + func + " from pid=" 7083 + Binder.getCallingPid() 7084 + ", uid=" + Binder.getCallingUid() 7085 + " requires " + permission; 7086 Slog.w(TAG, msg); 7087 throw new SecurityException(msg); 7088 } 7089 7090 /** 7091 * Determine if UID is holding permissions required to access {@link Uri} in 7092 * the given {@link ProviderInfo}. Final permission checking is always done 7093 * in {@link ContentProvider}. 7094 */ 7095 private final boolean checkHoldingPermissionsLocked( 7096 IPackageManager pm, ProviderInfo pi, GrantUri grantUri, int uid, final int modeFlags) { 7097 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7098 "checkHoldingPermissionsLocked: uri=" + grantUri + " uid=" + uid); 7099 if (UserHandle.getUserId(uid) != grantUri.sourceUserId) { 7100 if (ActivityManager.checkComponentPermission(INTERACT_ACROSS_USERS, uid, -1, true) 7101 != PERMISSION_GRANTED) { 7102 return false; 7103 } 7104 } 7105 return checkHoldingPermissionsInternalLocked(pm, pi, grantUri, uid, modeFlags, true); 7106 } 7107 7108 private final boolean checkHoldingPermissionsInternalLocked(IPackageManager pm, ProviderInfo pi, 7109 GrantUri grantUri, int uid, final int modeFlags, boolean considerUidPermissions) { 7110 if (pi.applicationInfo.uid == uid) { 7111 return true; 7112 } else if (!pi.exported) { 7113 return false; 7114 } 7115 7116 boolean readMet = (modeFlags & Intent.FLAG_GRANT_READ_URI_PERMISSION) == 0; 7117 boolean writeMet = (modeFlags & Intent.FLAG_GRANT_WRITE_URI_PERMISSION) == 0; 7118 try { 7119 // check if target holds top-level <provider> permissions 7120 if (!readMet && pi.readPermission != null && considerUidPermissions 7121 && (pm.checkUidPermission(pi.readPermission, uid) == PERMISSION_GRANTED)) { 7122 readMet = true; 7123 } 7124 if (!writeMet && pi.writePermission != null && considerUidPermissions 7125 && (pm.checkUidPermission(pi.writePermission, uid) == PERMISSION_GRANTED)) { 7126 writeMet = true; 7127 } 7128 7129 // track if unprotected read/write is allowed; any denied 7130 // <path-permission> below removes this ability 7131 boolean allowDefaultRead = pi.readPermission == null; 7132 boolean allowDefaultWrite = pi.writePermission == null; 7133 7134 // check if target holds any <path-permission> that match uri 7135 final PathPermission[] pps = pi.pathPermissions; 7136 if (pps != null) { 7137 final String path = grantUri.uri.getPath(); 7138 int i = pps.length; 7139 while (i > 0 && (!readMet || !writeMet)) { 7140 i--; 7141 PathPermission pp = pps[i]; 7142 if (pp.match(path)) { 7143 if (!readMet) { 7144 final String pprperm = pp.getReadPermission(); 7145 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7146 "Checking read perm for " + pprperm + " for " + pp.getPath() 7147 + ": match=" + pp.match(path) 7148 + " check=" + pm.checkUidPermission(pprperm, uid)); 7149 if (pprperm != null) { 7150 if (considerUidPermissions && pm.checkUidPermission(pprperm, uid) 7151 == PERMISSION_GRANTED) { 7152 readMet = true; 7153 } else { 7154 allowDefaultRead = false; 7155 } 7156 } 7157 } 7158 if (!writeMet) { 7159 final String ppwperm = pp.getWritePermission(); 7160 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7161 "Checking write perm " + ppwperm + " for " + pp.getPath() 7162 + ": match=" + pp.match(path) 7163 + " check=" + pm.checkUidPermission(ppwperm, uid)); 7164 if (ppwperm != null) { 7165 if (considerUidPermissions && pm.checkUidPermission(ppwperm, uid) 7166 == PERMISSION_GRANTED) { 7167 writeMet = true; 7168 } else { 7169 allowDefaultWrite = false; 7170 } 7171 } 7172 } 7173 } 7174 } 7175 } 7176 7177 // grant unprotected <provider> read/write, if not blocked by 7178 // <path-permission> above 7179 if (allowDefaultRead) readMet = true; 7180 if (allowDefaultWrite) writeMet = true; 7181 7182 } catch (RemoteException e) { 7183 return false; 7184 } 7185 7186 return readMet && writeMet; 7187 } 7188 7189 private ProviderInfo getProviderInfoLocked(String authority, int userHandle) { 7190 ProviderInfo pi = null; 7191 ContentProviderRecord cpr = mProviderMap.getProviderByName(authority, userHandle); 7192 if (cpr != null) { 7193 pi = cpr.info; 7194 } else { 7195 try { 7196 pi = AppGlobals.getPackageManager().resolveContentProvider( 7197 authority, PackageManager.GET_URI_PERMISSION_PATTERNS, userHandle); 7198 } catch (RemoteException ex) { 7199 } 7200 } 7201 return pi; 7202 } 7203 7204 private UriPermission findUriPermissionLocked(int targetUid, GrantUri grantUri) { 7205 final ArrayMap<GrantUri, UriPermission> targetUris = mGrantedUriPermissions.get(targetUid); 7206 if (targetUris != null) { 7207 return targetUris.get(grantUri); 7208 } 7209 return null; 7210 } 7211 7212 private UriPermission findOrCreateUriPermissionLocked(String sourcePkg, 7213 String targetPkg, int targetUid, GrantUri grantUri) { 7214 ArrayMap<GrantUri, UriPermission> targetUris = mGrantedUriPermissions.get(targetUid); 7215 if (targetUris == null) { 7216 targetUris = Maps.newArrayMap(); 7217 mGrantedUriPermissions.put(targetUid, targetUris); 7218 } 7219 7220 UriPermission perm = targetUris.get(grantUri); 7221 if (perm == null) { 7222 perm = new UriPermission(sourcePkg, targetPkg, targetUid, grantUri); 7223 targetUris.put(grantUri, perm); 7224 } 7225 7226 return perm; 7227 } 7228 7229 private final boolean checkUriPermissionLocked(GrantUri grantUri, int uid, 7230 final int modeFlags) { 7231 final boolean persistable = (modeFlags & Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION) != 0; 7232 final int minStrength = persistable ? UriPermission.STRENGTH_PERSISTABLE 7233 : UriPermission.STRENGTH_OWNED; 7234 7235 // Root gets to do everything. 7236 if (uid == 0) { 7237 return true; 7238 } 7239 7240 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get(uid); 7241 if (perms == null) return false; 7242 7243 // First look for exact match 7244 final UriPermission exactPerm = perms.get(grantUri); 7245 if (exactPerm != null && exactPerm.getStrength(modeFlags) >= minStrength) { 7246 return true; 7247 } 7248 7249 // No exact match, look for prefixes 7250 final int N = perms.size(); 7251 for (int i = 0; i < N; i++) { 7252 final UriPermission perm = perms.valueAt(i); 7253 if (perm.uri.prefix && grantUri.uri.isPathPrefixMatch(perm.uri.uri) 7254 && perm.getStrength(modeFlags) >= minStrength) { 7255 return true; 7256 } 7257 } 7258 7259 return false; 7260 } 7261 7262 /** 7263 * @param uri This uri must NOT contain an embedded userId. 7264 * @param userId The userId in which the uri is to be resolved. 7265 */ 7266 @Override 7267 public int checkUriPermission(Uri uri, int pid, int uid, 7268 final int modeFlags, int userId, IBinder callerToken) { 7269 enforceNotIsolatedCaller("checkUriPermission"); 7270 7271 // Another redirected-binder-call permissions check as in 7272 // {@link checkPermissionWithToken}. 7273 Identity tlsIdentity = sCallerIdentity.get(); 7274 if (tlsIdentity != null && tlsIdentity.token == callerToken) { 7275 uid = tlsIdentity.uid; 7276 pid = tlsIdentity.pid; 7277 } 7278 7279 // Our own process gets to do everything. 7280 if (pid == MY_PID) { 7281 return PackageManager.PERMISSION_GRANTED; 7282 } 7283 synchronized (this) { 7284 return checkUriPermissionLocked(new GrantUri(userId, uri, false), uid, modeFlags) 7285 ? PackageManager.PERMISSION_GRANTED 7286 : PackageManager.PERMISSION_DENIED; 7287 } 7288 } 7289 7290 /** 7291 * Check if the targetPkg can be granted permission to access uri by 7292 * the callingUid using the given modeFlags. Throws a security exception 7293 * if callingUid is not allowed to do this. Returns the uid of the target 7294 * if the URI permission grant should be performed; returns -1 if it is not 7295 * needed (for example targetPkg already has permission to access the URI). 7296 * If you already know the uid of the target, you can supply it in 7297 * lastTargetUid else set that to -1. 7298 */ 7299 int checkGrantUriPermissionLocked(int callingUid, String targetPkg, GrantUri grantUri, 7300 final int modeFlags, int lastTargetUid) { 7301 if (!Intent.isAccessUriMode(modeFlags)) { 7302 return -1; 7303 } 7304 7305 if (targetPkg != null) { 7306 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7307 "Checking grant " + targetPkg + " permission to " + grantUri); 7308 } 7309 7310 final IPackageManager pm = AppGlobals.getPackageManager(); 7311 7312 // If this is not a content: uri, we can't do anything with it. 7313 if (!ContentResolver.SCHEME_CONTENT.equals(grantUri.uri.getScheme())) { 7314 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7315 "Can't grant URI permission for non-content URI: " + grantUri); 7316 return -1; 7317 } 7318 7319 final String authority = grantUri.uri.getAuthority(); 7320 final ProviderInfo pi = getProviderInfoLocked(authority, grantUri.sourceUserId); 7321 if (pi == null) { 7322 Slog.w(TAG, "No content provider found for permission check: " + 7323 grantUri.uri.toSafeString()); 7324 return -1; 7325 } 7326 7327 int targetUid = lastTargetUid; 7328 if (targetUid < 0 && targetPkg != null) { 7329 try { 7330 targetUid = pm.getPackageUid(targetPkg, UserHandle.getUserId(callingUid)); 7331 if (targetUid < 0) { 7332 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7333 "Can't grant URI permission no uid for: " + targetPkg); 7334 return -1; 7335 } 7336 } catch (RemoteException ex) { 7337 return -1; 7338 } 7339 } 7340 7341 if (targetUid >= 0) { 7342 // First... does the target actually need this permission? 7343 if (checkHoldingPermissionsLocked(pm, pi, grantUri, targetUid, modeFlags)) { 7344 // No need to grant the target this permission. 7345 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7346 "Target " + targetPkg + " already has full permission to " + grantUri); 7347 return -1; 7348 } 7349 } else { 7350 // First... there is no target package, so can anyone access it? 7351 boolean allowed = pi.exported; 7352 if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { 7353 if (pi.readPermission != null) { 7354 allowed = false; 7355 } 7356 } 7357 if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { 7358 if (pi.writePermission != null) { 7359 allowed = false; 7360 } 7361 } 7362 if (allowed) { 7363 return -1; 7364 } 7365 } 7366 7367 /* There is a special cross user grant if: 7368 * - The target is on another user. 7369 * - Apps on the current user can access the uri without any uid permissions. 7370 * In this case, we grant a uri permission, even if the ContentProvider does not normally 7371 * grant uri permissions. 7372 */ 7373 boolean specialCrossUserGrant = UserHandle.getUserId(targetUid) != grantUri.sourceUserId 7374 && checkHoldingPermissionsInternalLocked(pm, pi, grantUri, callingUid, 7375 modeFlags, false /*without considering the uid permissions*/); 7376 7377 // Second... is the provider allowing granting of URI permissions? 7378 if (!specialCrossUserGrant) { 7379 if (!pi.grantUriPermissions) { 7380 throw new SecurityException("Provider " + pi.packageName 7381 + "/" + pi.name 7382 + " does not allow granting of Uri permissions (uri " 7383 + grantUri + ")"); 7384 } 7385 if (pi.uriPermissionPatterns != null) { 7386 final int N = pi.uriPermissionPatterns.length; 7387 boolean allowed = false; 7388 for (int i=0; i<N; i++) { 7389 if (pi.uriPermissionPatterns[i] != null 7390 && pi.uriPermissionPatterns[i].match(grantUri.uri.getPath())) { 7391 allowed = true; 7392 break; 7393 } 7394 } 7395 if (!allowed) { 7396 throw new SecurityException("Provider " + pi.packageName 7397 + "/" + pi.name 7398 + " does not allow granting of permission to path of Uri " 7399 + grantUri); 7400 } 7401 } 7402 } 7403 7404 // Third... does the caller itself have permission to access 7405 // this uri? 7406 if (UserHandle.getAppId(callingUid) != Process.SYSTEM_UID) { 7407 if (!checkHoldingPermissionsLocked(pm, pi, grantUri, callingUid, modeFlags)) { 7408 // Require they hold a strong enough Uri permission 7409 if (!checkUriPermissionLocked(grantUri, callingUid, modeFlags)) { 7410 throw new SecurityException("Uid " + callingUid 7411 + " does not have permission to uri " + grantUri); 7412 } 7413 } 7414 } 7415 return targetUid; 7416 } 7417 7418 /** 7419 * @param uri This uri must NOT contain an embedded userId. 7420 * @param userId The userId in which the uri is to be resolved. 7421 */ 7422 @Override 7423 public int checkGrantUriPermission(int callingUid, String targetPkg, Uri uri, 7424 final int modeFlags, int userId) { 7425 enforceNotIsolatedCaller("checkGrantUriPermission"); 7426 synchronized(this) { 7427 return checkGrantUriPermissionLocked(callingUid, targetPkg, 7428 new GrantUri(userId, uri, false), modeFlags, -1); 7429 } 7430 } 7431 7432 void grantUriPermissionUncheckedLocked(int targetUid, String targetPkg, GrantUri grantUri, 7433 final int modeFlags, UriPermissionOwner owner) { 7434 if (!Intent.isAccessUriMode(modeFlags)) { 7435 return; 7436 } 7437 7438 // So here we are: the caller has the assumed permission 7439 // to the uri, and the target doesn't. Let's now give this to 7440 // the target. 7441 7442 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7443 "Granting " + targetPkg + "/" + targetUid + " permission to " + grantUri); 7444 7445 final String authority = grantUri.uri.getAuthority(); 7446 final ProviderInfo pi = getProviderInfoLocked(authority, grantUri.sourceUserId); 7447 if (pi == null) { 7448 Slog.w(TAG, "No content provider found for grant: " + grantUri.toSafeString()); 7449 return; 7450 } 7451 7452 if ((modeFlags & Intent.FLAG_GRANT_PREFIX_URI_PERMISSION) != 0) { 7453 grantUri.prefix = true; 7454 } 7455 final UriPermission perm = findOrCreateUriPermissionLocked( 7456 pi.packageName, targetPkg, targetUid, grantUri); 7457 perm.grantModes(modeFlags, owner); 7458 } 7459 7460 void grantUriPermissionLocked(int callingUid, String targetPkg, GrantUri grantUri, 7461 final int modeFlags, UriPermissionOwner owner, int targetUserId) { 7462 if (targetPkg == null) { 7463 throw new NullPointerException("targetPkg"); 7464 } 7465 int targetUid; 7466 final IPackageManager pm = AppGlobals.getPackageManager(); 7467 try { 7468 targetUid = pm.getPackageUid(targetPkg, targetUserId); 7469 } catch (RemoteException ex) { 7470 return; 7471 } 7472 7473 targetUid = checkGrantUriPermissionLocked(callingUid, targetPkg, grantUri, modeFlags, 7474 targetUid); 7475 if (targetUid < 0) { 7476 return; 7477 } 7478 7479 grantUriPermissionUncheckedLocked(targetUid, targetPkg, grantUri, modeFlags, 7480 owner); 7481 } 7482 7483 static class NeededUriGrants extends ArrayList<GrantUri> { 7484 final String targetPkg; 7485 final int targetUid; 7486 final int flags; 7487 7488 NeededUriGrants(String targetPkg, int targetUid, int flags) { 7489 this.targetPkg = targetPkg; 7490 this.targetUid = targetUid; 7491 this.flags = flags; 7492 } 7493 } 7494 7495 /** 7496 * Like checkGrantUriPermissionLocked, but takes an Intent. 7497 */ 7498 NeededUriGrants checkGrantUriPermissionFromIntentLocked(int callingUid, 7499 String targetPkg, Intent intent, int mode, NeededUriGrants needed, int targetUserId) { 7500 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7501 "Checking URI perm to data=" + (intent != null ? intent.getData() : null) 7502 + " clip=" + (intent != null ? intent.getClipData() : null) 7503 + " from " + intent + "; flags=0x" 7504 + Integer.toHexString(intent != null ? intent.getFlags() : 0)); 7505 7506 if (targetPkg == null) { 7507 throw new NullPointerException("targetPkg"); 7508 } 7509 7510 if (intent == null) { 7511 return null; 7512 } 7513 Uri data = intent.getData(); 7514 ClipData clip = intent.getClipData(); 7515 if (data == null && clip == null) { 7516 return null; 7517 } 7518 // Default userId for uris in the intent (if they don't specify it themselves) 7519 int contentUserHint = intent.getContentUserHint(); 7520 if (contentUserHint == UserHandle.USER_CURRENT) { 7521 contentUserHint = UserHandle.getUserId(callingUid); 7522 } 7523 final IPackageManager pm = AppGlobals.getPackageManager(); 7524 int targetUid; 7525 if (needed != null) { 7526 targetUid = needed.targetUid; 7527 } else { 7528 try { 7529 targetUid = pm.getPackageUid(targetPkg, targetUserId); 7530 } catch (RemoteException ex) { 7531 return null; 7532 } 7533 if (targetUid < 0) { 7534 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7535 "Can't grant URI permission no uid for: " + targetPkg 7536 + " on user " + targetUserId); 7537 return null; 7538 } 7539 } 7540 if (data != null) { 7541 GrantUri grantUri = GrantUri.resolve(contentUserHint, data); 7542 targetUid = checkGrantUriPermissionLocked(callingUid, targetPkg, grantUri, mode, 7543 targetUid); 7544 if (targetUid > 0) { 7545 if (needed == null) { 7546 needed = new NeededUriGrants(targetPkg, targetUid, mode); 7547 } 7548 needed.add(grantUri); 7549 } 7550 } 7551 if (clip != null) { 7552 for (int i=0; i<clip.getItemCount(); i++) { 7553 Uri uri = clip.getItemAt(i).getUri(); 7554 if (uri != null) { 7555 GrantUri grantUri = GrantUri.resolve(contentUserHint, uri); 7556 targetUid = checkGrantUriPermissionLocked(callingUid, targetPkg, grantUri, mode, 7557 targetUid); 7558 if (targetUid > 0) { 7559 if (needed == null) { 7560 needed = new NeededUriGrants(targetPkg, targetUid, mode); 7561 } 7562 needed.add(grantUri); 7563 } 7564 } else { 7565 Intent clipIntent = clip.getItemAt(i).getIntent(); 7566 if (clipIntent != null) { 7567 NeededUriGrants newNeeded = checkGrantUriPermissionFromIntentLocked( 7568 callingUid, targetPkg, clipIntent, mode, needed, targetUserId); 7569 if (newNeeded != null) { 7570 needed = newNeeded; 7571 } 7572 } 7573 } 7574 } 7575 } 7576 7577 return needed; 7578 } 7579 7580 /** 7581 * Like grantUriPermissionUncheckedLocked, but takes an Intent. 7582 */ 7583 void grantUriPermissionUncheckedFromIntentLocked(NeededUriGrants needed, 7584 UriPermissionOwner owner) { 7585 if (needed != null) { 7586 for (int i=0; i<needed.size(); i++) { 7587 GrantUri grantUri = needed.get(i); 7588 grantUriPermissionUncheckedLocked(needed.targetUid, needed.targetPkg, 7589 grantUri, needed.flags, owner); 7590 } 7591 } 7592 } 7593 7594 void grantUriPermissionFromIntentLocked(int callingUid, 7595 String targetPkg, Intent intent, UriPermissionOwner owner, int targetUserId) { 7596 NeededUriGrants needed = checkGrantUriPermissionFromIntentLocked(callingUid, targetPkg, 7597 intent, intent != null ? intent.getFlags() : 0, null, targetUserId); 7598 if (needed == null) { 7599 return; 7600 } 7601 7602 grantUriPermissionUncheckedFromIntentLocked(needed, owner); 7603 } 7604 7605 /** 7606 * @param uri This uri must NOT contain an embedded userId. 7607 * @param userId The userId in which the uri is to be resolved. 7608 */ 7609 @Override 7610 public void grantUriPermission(IApplicationThread caller, String targetPkg, Uri uri, 7611 final int modeFlags, int userId) { 7612 enforceNotIsolatedCaller("grantUriPermission"); 7613 GrantUri grantUri = new GrantUri(userId, uri, false); 7614 synchronized(this) { 7615 final ProcessRecord r = getRecordForAppLocked(caller); 7616 if (r == null) { 7617 throw new SecurityException("Unable to find app for caller " 7618 + caller 7619 + " when granting permission to uri " + grantUri); 7620 } 7621 if (targetPkg == null) { 7622 throw new IllegalArgumentException("null target"); 7623 } 7624 if (grantUri == null) { 7625 throw new IllegalArgumentException("null uri"); 7626 } 7627 7628 Preconditions.checkFlagsArgument(modeFlags, Intent.FLAG_GRANT_READ_URI_PERMISSION 7629 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION 7630 | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION 7631 | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION); 7632 7633 grantUriPermissionLocked(r.uid, targetPkg, grantUri, modeFlags, null, 7634 UserHandle.getUserId(r.uid)); 7635 } 7636 } 7637 7638 void removeUriPermissionIfNeededLocked(UriPermission perm) { 7639 if (perm.modeFlags == 0) { 7640 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get( 7641 perm.targetUid); 7642 if (perms != null) { 7643 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7644 "Removing " + perm.targetUid + " permission to " + perm.uri); 7645 7646 perms.remove(perm.uri); 7647 if (perms.isEmpty()) { 7648 mGrantedUriPermissions.remove(perm.targetUid); 7649 } 7650 } 7651 } 7652 } 7653 7654 private void revokeUriPermissionLocked(int callingUid, GrantUri grantUri, final int modeFlags) { 7655 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7656 "Revoking all granted permissions to " + grantUri); 7657 7658 final IPackageManager pm = AppGlobals.getPackageManager(); 7659 final String authority = grantUri.uri.getAuthority(); 7660 final ProviderInfo pi = getProviderInfoLocked(authority, grantUri.sourceUserId); 7661 if (pi == null) { 7662 Slog.w(TAG, "No content provider found for permission revoke: " 7663 + grantUri.toSafeString()); 7664 return; 7665 } 7666 7667 // Does the caller have this permission on the URI? 7668 if (!checkHoldingPermissionsLocked(pm, pi, grantUri, callingUid, modeFlags)) { 7669 // If they don't have direct access to the URI, then revoke any 7670 // ownerless URI permissions that have been granted to them. 7671 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get(callingUid); 7672 if (perms != null) { 7673 boolean persistChanged = false; 7674 for (Iterator<UriPermission> it = perms.values().iterator(); it.hasNext();) { 7675 final UriPermission perm = it.next(); 7676 if (perm.uri.sourceUserId == grantUri.sourceUserId 7677 && perm.uri.uri.isPathPrefixMatch(grantUri.uri)) { 7678 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7679 "Revoking non-owned " + perm.targetUid 7680 + " permission to " + perm.uri); 7681 persistChanged |= perm.revokeModes( 7682 modeFlags | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION, false); 7683 if (perm.modeFlags == 0) { 7684 it.remove(); 7685 } 7686 } 7687 } 7688 if (perms.isEmpty()) { 7689 mGrantedUriPermissions.remove(callingUid); 7690 } 7691 if (persistChanged) { 7692 schedulePersistUriGrants(); 7693 } 7694 } 7695 return; 7696 } 7697 7698 boolean persistChanged = false; 7699 7700 // Go through all of the permissions and remove any that match. 7701 int N = mGrantedUriPermissions.size(); 7702 for (int i = 0; i < N; i++) { 7703 final int targetUid = mGrantedUriPermissions.keyAt(i); 7704 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.valueAt(i); 7705 7706 for (Iterator<UriPermission> it = perms.values().iterator(); it.hasNext();) { 7707 final UriPermission perm = it.next(); 7708 if (perm.uri.sourceUserId == grantUri.sourceUserId 7709 && perm.uri.uri.isPathPrefixMatch(grantUri.uri)) { 7710 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 7711 "Revoking " + perm.targetUid + " permission to " + perm.uri); 7712 persistChanged |= perm.revokeModes( 7713 modeFlags | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION, true); 7714 if (perm.modeFlags == 0) { 7715 it.remove(); 7716 } 7717 } 7718 } 7719 7720 if (perms.isEmpty()) { 7721 mGrantedUriPermissions.remove(targetUid); 7722 N--; 7723 i--; 7724 } 7725 } 7726 7727 if (persistChanged) { 7728 schedulePersistUriGrants(); 7729 } 7730 } 7731 7732 /** 7733 * @param uri This uri must NOT contain an embedded userId. 7734 * @param userId The userId in which the uri is to be resolved. 7735 */ 7736 @Override 7737 public void revokeUriPermission(IApplicationThread caller, Uri uri, final int modeFlags, 7738 int userId) { 7739 enforceNotIsolatedCaller("revokeUriPermission"); 7740 synchronized(this) { 7741 final ProcessRecord r = getRecordForAppLocked(caller); 7742 if (r == null) { 7743 throw new SecurityException("Unable to find app for caller " 7744 + caller 7745 + " when revoking permission to uri " + uri); 7746 } 7747 if (uri == null) { 7748 Slog.w(TAG, "revokeUriPermission: null uri"); 7749 return; 7750 } 7751 7752 if (!Intent.isAccessUriMode(modeFlags)) { 7753 return; 7754 } 7755 7756 final String authority = uri.getAuthority(); 7757 final ProviderInfo pi = getProviderInfoLocked(authority, userId); 7758 if (pi == null) { 7759 Slog.w(TAG, "No content provider found for permission revoke: " 7760 + uri.toSafeString()); 7761 return; 7762 } 7763 7764 revokeUriPermissionLocked(r.uid, new GrantUri(userId, uri, false), modeFlags); 7765 } 7766 } 7767 7768 /** 7769 * Remove any {@link UriPermission} granted <em>from</em> or <em>to</em> the 7770 * given package. 7771 * 7772 * @param packageName Package name to match, or {@code null} to apply to all 7773 * packages. 7774 * @param userHandle User to match, or {@link UserHandle#USER_ALL} to apply 7775 * to all users. 7776 * @param persistable If persistable grants should be removed. 7777 */ 7778 private void removeUriPermissionsForPackageLocked( 7779 String packageName, int userHandle, boolean persistable) { 7780 if (userHandle == UserHandle.USER_ALL && packageName == null) { 7781 throw new IllegalArgumentException("Must narrow by either package or user"); 7782 } 7783 7784 boolean persistChanged = false; 7785 7786 int N = mGrantedUriPermissions.size(); 7787 for (int i = 0; i < N; i++) { 7788 final int targetUid = mGrantedUriPermissions.keyAt(i); 7789 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.valueAt(i); 7790 7791 // Only inspect grants matching user 7792 if (userHandle == UserHandle.USER_ALL 7793 || userHandle == UserHandle.getUserId(targetUid)) { 7794 for (Iterator<UriPermission> it = perms.values().iterator(); it.hasNext();) { 7795 final UriPermission perm = it.next(); 7796 7797 // Only inspect grants matching package 7798 if (packageName == null || perm.sourcePkg.equals(packageName) 7799 || perm.targetPkg.equals(packageName)) { 7800 persistChanged |= perm.revokeModes(persistable 7801 ? ~0 : ~Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION, true); 7802 7803 // Only remove when no modes remain; any persisted grants 7804 // will keep this alive. 7805 if (perm.modeFlags == 0) { 7806 it.remove(); 7807 } 7808 } 7809 } 7810 7811 if (perms.isEmpty()) { 7812 mGrantedUriPermissions.remove(targetUid); 7813 N--; 7814 i--; 7815 } 7816 } 7817 } 7818 7819 if (persistChanged) { 7820 schedulePersistUriGrants(); 7821 } 7822 } 7823 7824 @Override 7825 public IBinder newUriPermissionOwner(String name) { 7826 enforceNotIsolatedCaller("newUriPermissionOwner"); 7827 synchronized(this) { 7828 UriPermissionOwner owner = new UriPermissionOwner(this, name); 7829 return owner.getExternalTokenLocked(); 7830 } 7831 } 7832 7833 /** 7834 * @param uri This uri must NOT contain an embedded userId. 7835 * @param sourceUserId The userId in which the uri is to be resolved. 7836 * @param targetUserId The userId of the app that receives the grant. 7837 */ 7838 @Override 7839 public void grantUriPermissionFromOwner(IBinder token, int fromUid, String targetPkg, Uri uri, 7840 final int modeFlags, int sourceUserId, int targetUserId) { 7841 targetUserId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), 7842 targetUserId, false, ALLOW_FULL_ONLY, "grantUriPermissionFromOwner", null); 7843 synchronized(this) { 7844 UriPermissionOwner owner = UriPermissionOwner.fromExternalToken(token); 7845 if (owner == null) { 7846 throw new IllegalArgumentException("Unknown owner: " + token); 7847 } 7848 if (fromUid != Binder.getCallingUid()) { 7849 if (Binder.getCallingUid() != Process.myUid()) { 7850 // Only system code can grant URI permissions on behalf 7851 // of other users. 7852 throw new SecurityException("nice try"); 7853 } 7854 } 7855 if (targetPkg == null) { 7856 throw new IllegalArgumentException("null target"); 7857 } 7858 if (uri == null) { 7859 throw new IllegalArgumentException("null uri"); 7860 } 7861 7862 grantUriPermissionLocked(fromUid, targetPkg, new GrantUri(sourceUserId, uri, false), 7863 modeFlags, owner, targetUserId); 7864 } 7865 } 7866 7867 /** 7868 * @param uri This uri must NOT contain an embedded userId. 7869 * @param userId The userId in which the uri is to be resolved. 7870 */ 7871 @Override 7872 public void revokeUriPermissionFromOwner(IBinder token, Uri uri, int mode, int userId) { 7873 synchronized(this) { 7874 UriPermissionOwner owner = UriPermissionOwner.fromExternalToken(token); 7875 if (owner == null) { 7876 throw new IllegalArgumentException("Unknown owner: " + token); 7877 } 7878 7879 if (uri == null) { 7880 owner.removeUriPermissionsLocked(mode); 7881 } else { 7882 owner.removeUriPermissionLocked(new GrantUri(userId, uri, false), mode); 7883 } 7884 } 7885 } 7886 7887 private void schedulePersistUriGrants() { 7888 if (!mHandler.hasMessages(PERSIST_URI_GRANTS_MSG)) { 7889 mHandler.sendMessageDelayed(mHandler.obtainMessage(PERSIST_URI_GRANTS_MSG), 7890 10 * DateUtils.SECOND_IN_MILLIS); 7891 } 7892 } 7893 7894 private void writeGrantedUriPermissions() { 7895 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, "writeGrantedUriPermissions()"); 7896 7897 // Snapshot permissions so we can persist without lock 7898 ArrayList<UriPermission.Snapshot> persist = Lists.newArrayList(); 7899 synchronized (this) { 7900 final int size = mGrantedUriPermissions.size(); 7901 for (int i = 0; i < size; i++) { 7902 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.valueAt(i); 7903 for (UriPermission perm : perms.values()) { 7904 if (perm.persistedModeFlags != 0) { 7905 persist.add(perm.snapshot()); 7906 } 7907 } 7908 } 7909 } 7910 7911 FileOutputStream fos = null; 7912 try { 7913 fos = mGrantFile.startWrite(); 7914 7915 XmlSerializer out = new FastXmlSerializer(); 7916 out.setOutput(fos, StandardCharsets.UTF_8.name()); 7917 out.startDocument(null, true); 7918 out.startTag(null, TAG_URI_GRANTS); 7919 for (UriPermission.Snapshot perm : persist) { 7920 out.startTag(null, TAG_URI_GRANT); 7921 writeIntAttribute(out, ATTR_SOURCE_USER_ID, perm.uri.sourceUserId); 7922 writeIntAttribute(out, ATTR_TARGET_USER_ID, perm.targetUserId); 7923 out.attribute(null, ATTR_SOURCE_PKG, perm.sourcePkg); 7924 out.attribute(null, ATTR_TARGET_PKG, perm.targetPkg); 7925 out.attribute(null, ATTR_URI, String.valueOf(perm.uri.uri)); 7926 writeBooleanAttribute(out, ATTR_PREFIX, perm.uri.prefix); 7927 writeIntAttribute(out, ATTR_MODE_FLAGS, perm.persistedModeFlags); 7928 writeLongAttribute(out, ATTR_CREATED_TIME, perm.persistedCreateTime); 7929 out.endTag(null, TAG_URI_GRANT); 7930 } 7931 out.endTag(null, TAG_URI_GRANTS); 7932 out.endDocument(); 7933 7934 mGrantFile.finishWrite(fos); 7935 } catch (IOException e) { 7936 if (fos != null) { 7937 mGrantFile.failWrite(fos); 7938 } 7939 } 7940 } 7941 7942 private void readGrantedUriPermissionsLocked() { 7943 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, "readGrantedUriPermissions()"); 7944 7945 final long now = System.currentTimeMillis(); 7946 7947 FileInputStream fis = null; 7948 try { 7949 fis = mGrantFile.openRead(); 7950 final XmlPullParser in = Xml.newPullParser(); 7951 in.setInput(fis, StandardCharsets.UTF_8.name()); 7952 7953 int type; 7954 while ((type = in.next()) != END_DOCUMENT) { 7955 final String tag = in.getName(); 7956 if (type == START_TAG) { 7957 if (TAG_URI_GRANT.equals(tag)) { 7958 final int sourceUserId; 7959 final int targetUserId; 7960 final int userHandle = readIntAttribute(in, 7961 ATTR_USER_HANDLE, UserHandle.USER_NULL); 7962 if (userHandle != UserHandle.USER_NULL) { 7963 // For backwards compatibility. 7964 sourceUserId = userHandle; 7965 targetUserId = userHandle; 7966 } else { 7967 sourceUserId = readIntAttribute(in, ATTR_SOURCE_USER_ID); 7968 targetUserId = readIntAttribute(in, ATTR_TARGET_USER_ID); 7969 } 7970 final String sourcePkg = in.getAttributeValue(null, ATTR_SOURCE_PKG); 7971 final String targetPkg = in.getAttributeValue(null, ATTR_TARGET_PKG); 7972 final Uri uri = Uri.parse(in.getAttributeValue(null, ATTR_URI)); 7973 final boolean prefix = readBooleanAttribute(in, ATTR_PREFIX); 7974 final int modeFlags = readIntAttribute(in, ATTR_MODE_FLAGS); 7975 final long createdTime = readLongAttribute(in, ATTR_CREATED_TIME, now); 7976 7977 // Sanity check that provider still belongs to source package 7978 final ProviderInfo pi = getProviderInfoLocked( 7979 uri.getAuthority(), sourceUserId); 7980 if (pi != null && sourcePkg.equals(pi.packageName)) { 7981 int targetUid = -1; 7982 try { 7983 targetUid = AppGlobals.getPackageManager() 7984 .getPackageUid(targetPkg, targetUserId); 7985 } catch (RemoteException e) { 7986 } 7987 if (targetUid != -1) { 7988 final UriPermission perm = findOrCreateUriPermissionLocked( 7989 sourcePkg, targetPkg, targetUid, 7990 new GrantUri(sourceUserId, uri, prefix)); 7991 perm.initPersistedModes(modeFlags, createdTime); 7992 } 7993 } else { 7994 Slog.w(TAG, "Persisted grant for " + uri + " had source " + sourcePkg 7995 + " but instead found " + pi); 7996 } 7997 } 7998 } 7999 } 8000 } catch (FileNotFoundException e) { 8001 // Missing grants is okay 8002 } catch (IOException e) { 8003 Slog.wtf(TAG, "Failed reading Uri grants", e); 8004 } catch (XmlPullParserException e) { 8005 Slog.wtf(TAG, "Failed reading Uri grants", e); 8006 } finally { 8007 IoUtils.closeQuietly(fis); 8008 } 8009 } 8010 8011 /** 8012 * @param uri This uri must NOT contain an embedded userId. 8013 * @param userId The userId in which the uri is to be resolved. 8014 */ 8015 @Override 8016 public void takePersistableUriPermission(Uri uri, final int modeFlags, int userId) { 8017 enforceNotIsolatedCaller("takePersistableUriPermission"); 8018 8019 Preconditions.checkFlagsArgument(modeFlags, 8020 Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); 8021 8022 synchronized (this) { 8023 final int callingUid = Binder.getCallingUid(); 8024 boolean persistChanged = false; 8025 GrantUri grantUri = new GrantUri(userId, uri, false); 8026 8027 UriPermission exactPerm = findUriPermissionLocked(callingUid, 8028 new GrantUri(userId, uri, false)); 8029 UriPermission prefixPerm = findUriPermissionLocked(callingUid, 8030 new GrantUri(userId, uri, true)); 8031 8032 final boolean exactValid = (exactPerm != null) 8033 && ((modeFlags & exactPerm.persistableModeFlags) == modeFlags); 8034 final boolean prefixValid = (prefixPerm != null) 8035 && ((modeFlags & prefixPerm.persistableModeFlags) == modeFlags); 8036 8037 if (!(exactValid || prefixValid)) { 8038 throw new SecurityException("No persistable permission grants found for UID " 8039 + callingUid + " and Uri " + grantUri.toSafeString()); 8040 } 8041 8042 if (exactValid) { 8043 persistChanged |= exactPerm.takePersistableModes(modeFlags); 8044 } 8045 if (prefixValid) { 8046 persistChanged |= prefixPerm.takePersistableModes(modeFlags); 8047 } 8048 8049 persistChanged |= maybePrunePersistedUriGrantsLocked(callingUid); 8050 8051 if (persistChanged) { 8052 schedulePersistUriGrants(); 8053 } 8054 } 8055 } 8056 8057 /** 8058 * @param uri This uri must NOT contain an embedded userId. 8059 * @param userId The userId in which the uri is to be resolved. 8060 */ 8061 @Override 8062 public void releasePersistableUriPermission(Uri uri, final int modeFlags, int userId) { 8063 enforceNotIsolatedCaller("releasePersistableUriPermission"); 8064 8065 Preconditions.checkFlagsArgument(modeFlags, 8066 Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); 8067 8068 synchronized (this) { 8069 final int callingUid = Binder.getCallingUid(); 8070 boolean persistChanged = false; 8071 8072 UriPermission exactPerm = findUriPermissionLocked(callingUid, 8073 new GrantUri(userId, uri, false)); 8074 UriPermission prefixPerm = findUriPermissionLocked(callingUid, 8075 new GrantUri(userId, uri, true)); 8076 if (exactPerm == null && prefixPerm == null) { 8077 throw new SecurityException("No permission grants found for UID " + callingUid 8078 + " and Uri " + uri.toSafeString()); 8079 } 8080 8081 if (exactPerm != null) { 8082 persistChanged |= exactPerm.releasePersistableModes(modeFlags); 8083 removeUriPermissionIfNeededLocked(exactPerm); 8084 } 8085 if (prefixPerm != null) { 8086 persistChanged |= prefixPerm.releasePersistableModes(modeFlags); 8087 removeUriPermissionIfNeededLocked(prefixPerm); 8088 } 8089 8090 if (persistChanged) { 8091 schedulePersistUriGrants(); 8092 } 8093 } 8094 } 8095 8096 /** 8097 * Prune any older {@link UriPermission} for the given UID until outstanding 8098 * persisted grants are below {@link #MAX_PERSISTED_URI_GRANTS}. 8099 * 8100 * @return if any mutations occured that require persisting. 8101 */ 8102 private boolean maybePrunePersistedUriGrantsLocked(int uid) { 8103 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get(uid); 8104 if (perms == null) return false; 8105 if (perms.size() < MAX_PERSISTED_URI_GRANTS) return false; 8106 8107 final ArrayList<UriPermission> persisted = Lists.newArrayList(); 8108 for (UriPermission perm : perms.values()) { 8109 if (perm.persistedModeFlags != 0) { 8110 persisted.add(perm); 8111 } 8112 } 8113 8114 final int trimCount = persisted.size() - MAX_PERSISTED_URI_GRANTS; 8115 if (trimCount <= 0) return false; 8116 8117 Collections.sort(persisted, new UriPermission.PersistedTimeComparator()); 8118 for (int i = 0; i < trimCount; i++) { 8119 final UriPermission perm = persisted.get(i); 8120 8121 if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION, 8122 "Trimming grant created at " + perm.persistedCreateTime); 8123 8124 perm.releasePersistableModes(~0); 8125 removeUriPermissionIfNeededLocked(perm); 8126 } 8127 8128 return true; 8129 } 8130 8131 @Override 8132 public ParceledListSlice<android.content.UriPermission> getPersistedUriPermissions( 8133 String packageName, boolean incoming) { 8134 enforceNotIsolatedCaller("getPersistedUriPermissions"); 8135 Preconditions.checkNotNull(packageName, "packageName"); 8136 8137 final int callingUid = Binder.getCallingUid(); 8138 final IPackageManager pm = AppGlobals.getPackageManager(); 8139 try { 8140 final int packageUid = pm.getPackageUid(packageName, UserHandle.getUserId(callingUid)); 8141 if (packageUid != callingUid) { 8142 throw new SecurityException( 8143 "Package " + packageName + " does not belong to calling UID " + callingUid); 8144 } 8145 } catch (RemoteException e) { 8146 throw new SecurityException("Failed to verify package name ownership"); 8147 } 8148 8149 final ArrayList<android.content.UriPermission> result = Lists.newArrayList(); 8150 synchronized (this) { 8151 if (incoming) { 8152 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get( 8153 callingUid); 8154 if (perms == null) { 8155 Slog.w(TAG, "No permission grants found for " + packageName); 8156 } else { 8157 for (UriPermission perm : perms.values()) { 8158 if (packageName.equals(perm.targetPkg) && perm.persistedModeFlags != 0) { 8159 result.add(perm.buildPersistedPublicApiObject()); 8160 } 8161 } 8162 } 8163 } else { 8164 final int size = mGrantedUriPermissions.size(); 8165 for (int i = 0; i < size; i++) { 8166 final ArrayMap<GrantUri, UriPermission> perms = 8167 mGrantedUriPermissions.valueAt(i); 8168 for (UriPermission perm : perms.values()) { 8169 if (packageName.equals(perm.sourcePkg) && perm.persistedModeFlags != 0) { 8170 result.add(perm.buildPersistedPublicApiObject()); 8171 } 8172 } 8173 } 8174 } 8175 } 8176 return new ParceledListSlice<android.content.UriPermission>(result); 8177 } 8178 8179 @Override 8180 public void showWaitingForDebugger(IApplicationThread who, boolean waiting) { 8181 synchronized (this) { 8182 ProcessRecord app = 8183 who != null ? getRecordForAppLocked(who) : null; 8184 if (app == null) return; 8185 8186 Message msg = Message.obtain(); 8187 msg.what = WAIT_FOR_DEBUGGER_MSG; 8188 msg.obj = app; 8189 msg.arg1 = waiting ? 1 : 0; 8190 mUiHandler.sendMessage(msg); 8191 } 8192 } 8193 8194 @Override 8195 public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) { 8196 final long homeAppMem = mProcessList.getMemLevel(ProcessList.HOME_APP_ADJ); 8197 final long cachedAppMem = mProcessList.getMemLevel(ProcessList.CACHED_APP_MIN_ADJ); 8198 outInfo.availMem = Process.getFreeMemory(); 8199 outInfo.totalMem = Process.getTotalMemory(); 8200 outInfo.threshold = homeAppMem; 8201 outInfo.lowMemory = outInfo.availMem < (homeAppMem + ((cachedAppMem-homeAppMem)/2)); 8202 outInfo.hiddenAppThreshold = cachedAppMem; 8203 outInfo.secondaryServerThreshold = mProcessList.getMemLevel( 8204 ProcessList.SERVICE_ADJ); 8205 outInfo.visibleAppThreshold = mProcessList.getMemLevel( 8206 ProcessList.VISIBLE_APP_ADJ); 8207 outInfo.foregroundAppThreshold = mProcessList.getMemLevel( 8208 ProcessList.FOREGROUND_APP_ADJ); 8209 } 8210 8211 // ========================================================= 8212 // TASK MANAGEMENT 8213 // ========================================================= 8214 8215 @Override 8216 public List<IAppTask> getAppTasks(String callingPackage) { 8217 int callingUid = Binder.getCallingUid(); 8218 long ident = Binder.clearCallingIdentity(); 8219 8220 synchronized(this) { 8221 ArrayList<IAppTask> list = new ArrayList<IAppTask>(); 8222 try { 8223 if (DEBUG_ALL) Slog.v(TAG, "getAppTasks"); 8224 8225 final int N = mRecentTasks.size(); 8226 for (int i = 0; i < N; i++) { 8227 TaskRecord tr = mRecentTasks.get(i); 8228 // Skip tasks that do not match the caller. We don't need to verify 8229 // callingPackage, because we are also limiting to callingUid and know 8230 // that will limit to the correct security sandbox. 8231 if (tr.effectiveUid != callingUid) { 8232 continue; 8233 } 8234 Intent intent = tr.getBaseIntent(); 8235 if (intent == null || 8236 !callingPackage.equals(intent.getComponent().getPackageName())) { 8237 continue; 8238 } 8239 ActivityManager.RecentTaskInfo taskInfo = 8240 createRecentTaskInfoFromTaskRecord(tr); 8241 AppTaskImpl taskImpl = new AppTaskImpl(taskInfo.persistentId, callingUid); 8242 list.add(taskImpl); 8243 } 8244 } finally { 8245 Binder.restoreCallingIdentity(ident); 8246 } 8247 return list; 8248 } 8249 } 8250 8251 @Override 8252 public List<RunningTaskInfo> getTasks(int maxNum, int flags) { 8253 final int callingUid = Binder.getCallingUid(); 8254 ArrayList<RunningTaskInfo> list = new ArrayList<RunningTaskInfo>(); 8255 8256 synchronized(this) { 8257 if (DEBUG_ALL) Slog.v( 8258 TAG, "getTasks: max=" + maxNum + ", flags=" + flags); 8259 8260 final boolean allowed = isGetTasksAllowed("getTasks", Binder.getCallingPid(), 8261 callingUid); 8262 8263 // TODO: Improve with MRU list from all ActivityStacks. 8264 mStackSupervisor.getTasksLocked(maxNum, list, callingUid, allowed); 8265 } 8266 8267 return list; 8268 } 8269 8270 /** 8271 * Creates a new RecentTaskInfo from a TaskRecord. 8272 */ 8273 private ActivityManager.RecentTaskInfo createRecentTaskInfoFromTaskRecord(TaskRecord tr) { 8274 // Update the task description to reflect any changes in the task stack 8275 tr.updateTaskDescription(); 8276 8277 // Compose the recent task info 8278 ActivityManager.RecentTaskInfo rti = new ActivityManager.RecentTaskInfo(); 8279 rti.id = tr.getTopActivity() == null ? INVALID_TASK_ID : tr.taskId; 8280 rti.persistentId = tr.taskId; 8281 rti.baseIntent = new Intent(tr.getBaseIntent()); 8282 rti.origActivity = tr.origActivity; 8283 rti.description = tr.lastDescription; 8284 rti.stackId = tr.stack != null ? tr.stack.mStackId : -1; 8285 rti.userId = tr.userId; 8286 rti.taskDescription = new ActivityManager.TaskDescription(tr.lastTaskDescription); 8287 rti.firstActiveTime = tr.firstActiveTime; 8288 rti.lastActiveTime = tr.lastActiveTime; 8289 rti.affiliatedTaskId = tr.mAffiliatedTaskId; 8290 rti.affiliatedTaskColor = tr.mAffiliatedTaskColor; 8291 rti.numActivities = 0; 8292 8293 ActivityRecord base = null; 8294 ActivityRecord top = null; 8295 ActivityRecord tmp; 8296 8297 for (int i = tr.mActivities.size() - 1; i >= 0; --i) { 8298 tmp = tr.mActivities.get(i); 8299 if (tmp.finishing) { 8300 continue; 8301 } 8302 base = tmp; 8303 if (top == null || (top.state == ActivityState.INITIALIZING)) { 8304 top = base; 8305 } 8306 rti.numActivities++; 8307 } 8308 8309 rti.baseActivity = (base != null) ? base.intent.getComponent() : null; 8310 rti.topActivity = (top != null) ? top.intent.getComponent() : null; 8311 8312 return rti; 8313 } 8314 8315 private boolean isGetTasksAllowed(String caller, int callingPid, int callingUid) { 8316 boolean allowed = checkPermission(android.Manifest.permission.REAL_GET_TASKS, 8317 callingPid, callingUid) == PackageManager.PERMISSION_GRANTED; 8318 if (!allowed) { 8319 if (checkPermission(android.Manifest.permission.GET_TASKS, 8320 callingPid, callingUid) == PackageManager.PERMISSION_GRANTED) { 8321 // Temporary compatibility: some existing apps on the system image may 8322 // still be requesting the old permission and not switched to the new 8323 // one; if so, we'll still allow them full access. This means we need 8324 // to see if they are holding the old permission and are a system app. 8325 try { 8326 if (AppGlobals.getPackageManager().isUidPrivileged(callingUid)) { 8327 allowed = true; 8328 if (DEBUG_TASKS) Slog.w(TAG, caller + ": caller " + callingUid 8329 + " is using old GET_TASKS but privileged; allowing"); 8330 } 8331 } catch (RemoteException e) { 8332 } 8333 } 8334 } 8335 if (!allowed) { 8336 if (DEBUG_TASKS) Slog.w(TAG, caller + ": caller " + callingUid 8337 + " does not hold REAL_GET_TASKS; limiting output"); 8338 } 8339 return allowed; 8340 } 8341 8342 @Override 8343 public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags, int userId) { 8344 final int callingUid = Binder.getCallingUid(); 8345 userId = handleIncomingUser(Binder.getCallingPid(), callingUid, userId, 8346 false, ALLOW_FULL_ONLY, "getRecentTasks", null); 8347 8348 final boolean includeProfiles = (flags & ActivityManager.RECENT_INCLUDE_PROFILES) != 0; 8349 final boolean withExcluded = (flags&ActivityManager.RECENT_WITH_EXCLUDED) != 0; 8350 synchronized (this) { 8351 final boolean allowed = isGetTasksAllowed("getRecentTasks", Binder.getCallingPid(), 8352 callingUid); 8353 final boolean detailed = checkCallingPermission( 8354 android.Manifest.permission.GET_DETAILED_TASKS) 8355 == PackageManager.PERMISSION_GRANTED; 8356 8357 final int recentsCount = mRecentTasks.size(); 8358 ArrayList<ActivityManager.RecentTaskInfo> res = 8359 new ArrayList<>(maxNum < recentsCount ? maxNum : recentsCount); 8360 8361 final Set<Integer> includedUsers; 8362 if (includeProfiles) { 8363 includedUsers = getProfileIdsLocked(userId); 8364 } else { 8365 includedUsers = new HashSet<>(); 8366 } 8367 includedUsers.add(Integer.valueOf(userId)); 8368 8369 for (int i = 0; i < recentsCount && maxNum > 0; i++) { 8370 TaskRecord tr = mRecentTasks.get(i); 8371 // Only add calling user or related users recent tasks 8372 if (!includedUsers.contains(Integer.valueOf(tr.userId))) { 8373 if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not user: " + tr); 8374 continue; 8375 } 8376 8377 // Return the entry if desired by the caller. We always return 8378 // the first entry, because callers always expect this to be the 8379 // foreground app. We may filter others if the caller has 8380 // not supplied RECENT_WITH_EXCLUDED and there is some reason 8381 // we should exclude the entry. 8382 8383 if (i == 0 8384 || withExcluded 8385 || (tr.intent == null) 8386 || ((tr.intent.getFlags() & Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) 8387 == 0)) { 8388 if (!allowed) { 8389 // If the caller doesn't have the GET_TASKS permission, then only 8390 // allow them to see a small subset of tasks -- their own and home. 8391 if (!tr.isHomeTask() && tr.effectiveUid != callingUid) { 8392 if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, "Skipping, not allowed: " + tr); 8393 continue; 8394 } 8395 } 8396 if ((flags & ActivityManager.RECENT_IGNORE_HOME_STACK_TASKS) != 0) { 8397 if (tr.stack != null && tr.stack.isHomeStack()) { 8398 if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, 8399 "Skipping, home stack task: " + tr); 8400 continue; 8401 } 8402 } 8403 if (tr.autoRemoveRecents && tr.getTopActivity() == null) { 8404 // Don't include auto remove tasks that are finished or finishing. 8405 if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, 8406 "Skipping, auto-remove without activity: " + tr); 8407 continue; 8408 } 8409 if ((flags&ActivityManager.RECENT_IGNORE_UNAVAILABLE) != 0 8410 && !tr.isAvailable) { 8411 if (DEBUG_RECENTS) Slog.d(TAG_RECENTS, 8412 "Skipping, unavail real act: " + tr); 8413 continue; 8414 } 8415 8416 ActivityManager.RecentTaskInfo rti = createRecentTaskInfoFromTaskRecord(tr); 8417 if (!detailed) { 8418 rti.baseIntent.replaceExtras((Bundle)null); 8419 } 8420 8421 res.add(rti); 8422 maxNum--; 8423 } 8424 } 8425 return res; 8426 } 8427 } 8428 8429 @Override 8430 public ActivityManager.TaskThumbnail getTaskThumbnail(int id) { 8431 synchronized (this) { 8432 enforceCallingPermission(android.Manifest.permission.READ_FRAME_BUFFER, 8433 "getTaskThumbnail()"); 8434 TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(id, false); 8435 if (tr != null) { 8436 return tr.getTaskThumbnailLocked(); 8437 } 8438 } 8439 return null; 8440 } 8441 8442 @Override 8443 public int addAppTask(IBinder activityToken, Intent intent, 8444 ActivityManager.TaskDescription description, Bitmap thumbnail) throws RemoteException { 8445 final int callingUid = Binder.getCallingUid(); 8446 final long callingIdent = Binder.clearCallingIdentity(); 8447 8448 try { 8449 synchronized (this) { 8450 ActivityRecord r = ActivityRecord.isInStackLocked(activityToken); 8451 if (r == null) { 8452 throw new IllegalArgumentException("Activity does not exist; token=" 8453 + activityToken); 8454 } 8455 ComponentName comp = intent.getComponent(); 8456 if (comp == null) { 8457 throw new IllegalArgumentException("Intent " + intent 8458 + " must specify explicit component"); 8459 } 8460 if (thumbnail.getWidth() != mThumbnailWidth 8461 || thumbnail.getHeight() != mThumbnailHeight) { 8462 throw new IllegalArgumentException("Bad thumbnail size: got " 8463 + thumbnail.getWidth() + "x" + thumbnail.getHeight() + ", require " 8464 + mThumbnailWidth + "x" + mThumbnailHeight); 8465 } 8466 if (intent.getSelector() != null) { 8467 intent.setSelector(null); 8468 } 8469 if (intent.getSourceBounds() != null) { 8470 intent.setSourceBounds(null); 8471 } 8472 if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_DOCUMENT) != 0) { 8473 if ((intent.getFlags()&Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS) == 0) { 8474 // The caller has added this as an auto-remove task... that makes no 8475 // sense, so turn off auto-remove. 8476 intent.addFlags(Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS); 8477 } 8478 } else if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { 8479 // Must be a new task. 8480 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 8481 } 8482 if (!comp.equals(mLastAddedTaskComponent) || callingUid != mLastAddedTaskUid) { 8483 mLastAddedTaskActivity = null; 8484 } 8485 ActivityInfo ainfo = mLastAddedTaskActivity; 8486 if (ainfo == null) { 8487 ainfo = mLastAddedTaskActivity = AppGlobals.getPackageManager().getActivityInfo( 8488 comp, 0, UserHandle.getUserId(callingUid)); 8489 if (ainfo.applicationInfo.uid != callingUid) { 8490 throw new SecurityException( 8491 "Can't add task for another application: target uid=" 8492 + ainfo.applicationInfo.uid + ", calling uid=" + callingUid); 8493 } 8494 } 8495 8496 TaskRecord task = new TaskRecord(this, mStackSupervisor.getNextTaskId(), ainfo, 8497 intent, description); 8498 8499 int trimIdx = mRecentTasks.trimForTaskLocked(task, false); 8500 if (trimIdx >= 0) { 8501 // If this would have caused a trim, then we'll abort because that 8502 // means it would be added at the end of the list but then just removed. 8503 return INVALID_TASK_ID; 8504 } 8505 8506 final int N = mRecentTasks.size(); 8507 if (N >= (ActivityManager.getMaxRecentTasksStatic()-1)) { 8508 final TaskRecord tr = mRecentTasks.remove(N - 1); 8509 tr.removedFromRecents(); 8510 } 8511 8512 task.inRecents = true; 8513 mRecentTasks.add(task); 8514 r.task.stack.addTask(task, false, false); 8515 8516 task.setLastThumbnail(thumbnail); 8517 task.freeLastThumbnail(); 8518 8519 return task.taskId; 8520 } 8521 } finally { 8522 Binder.restoreCallingIdentity(callingIdent); 8523 } 8524 } 8525 8526 @Override 8527 public Point getAppTaskThumbnailSize() { 8528 synchronized (this) { 8529 return new Point(mThumbnailWidth, mThumbnailHeight); 8530 } 8531 } 8532 8533 @Override 8534 public void setTaskDescription(IBinder token, ActivityManager.TaskDescription td) { 8535 synchronized (this) { 8536 ActivityRecord r = ActivityRecord.isInStackLocked(token); 8537 if (r != null) { 8538 r.setTaskDescription(td); 8539 r.task.updateTaskDescription(); 8540 } 8541 } 8542 } 8543 8544 @Override 8545 public void setTaskResizeable(int taskId, boolean resizeable) { 8546 synchronized (this) { 8547 TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId, false); 8548 if (task == null) { 8549 Slog.w(TAG, "setTaskResizeable: taskId=" + taskId + " not found"); 8550 return; 8551 } 8552 if (task.mResizeable != resizeable) { 8553 task.mResizeable = resizeable; 8554 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0); 8555 mStackSupervisor.resumeTopActivitiesLocked(); 8556 } 8557 } 8558 } 8559 8560 @Override 8561 public void resizeTask(int taskId, Rect bounds) { 8562 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8563 "resizeTask()"); 8564 long ident = Binder.clearCallingIdentity(); 8565 try { 8566 synchronized (this) { 8567 TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId); 8568 if (task == null) { 8569 Slog.w(TAG, "resizeTask: taskId=" + taskId + " not found"); 8570 return; 8571 } 8572 mStackSupervisor.resizeTaskLocked(task, bounds); 8573 } 8574 } finally { 8575 Binder.restoreCallingIdentity(ident); 8576 } 8577 } 8578 8579 @Override 8580 public Bitmap getTaskDescriptionIcon(String filename) { 8581 if (!FileUtils.isValidExtFilename(filename) 8582 || !filename.contains(ActivityRecord.ACTIVITY_ICON_SUFFIX)) { 8583 throw new IllegalArgumentException("Bad filename: " + filename); 8584 } 8585 return mTaskPersister.getTaskDescriptionIcon(filename); 8586 } 8587 8588 @Override 8589 public void startInPlaceAnimationOnFrontMostApplication(ActivityOptions opts) 8590 throws RemoteException { 8591 if (opts.getAnimationType() != ActivityOptions.ANIM_CUSTOM_IN_PLACE || 8592 opts.getCustomInPlaceResId() == 0) { 8593 throw new IllegalArgumentException("Expected in-place ActivityOption " + 8594 "with valid animation"); 8595 } 8596 mWindowManager.prepareAppTransition(AppTransition.TRANSIT_TASK_IN_PLACE, false); 8597 mWindowManager.overridePendingAppTransitionInPlace(opts.getPackageName(), 8598 opts.getCustomInPlaceResId()); 8599 mWindowManager.executeAppTransition(); 8600 } 8601 8602 private void cleanUpRemovedTaskLocked(TaskRecord tr, boolean killProcess) { 8603 mRecentTasks.remove(tr); 8604 tr.removedFromRecents(); 8605 ComponentName component = tr.getBaseIntent().getComponent(); 8606 if (component == null) { 8607 Slog.w(TAG, "No component for base intent of task: " + tr); 8608 return; 8609 } 8610 8611 // Find any running services associated with this app and stop if needed. 8612 mServices.cleanUpRemovedTaskLocked(tr, component, new Intent(tr.getBaseIntent())); 8613 8614 if (!killProcess) { 8615 return; 8616 } 8617 8618 // Determine if the process(es) for this task should be killed. 8619 final String pkg = component.getPackageName(); 8620 ArrayList<ProcessRecord> procsToKill = new ArrayList<>(); 8621 ArrayMap<String, SparseArray<ProcessRecord>> pmap = mProcessNames.getMap(); 8622 for (int i = 0; i < pmap.size(); i++) { 8623 8624 SparseArray<ProcessRecord> uids = pmap.valueAt(i); 8625 for (int j = 0; j < uids.size(); j++) { 8626 ProcessRecord proc = uids.valueAt(j); 8627 if (proc.userId != tr.userId) { 8628 // Don't kill process for a different user. 8629 continue; 8630 } 8631 if (proc == mHomeProcess) { 8632 // Don't kill the home process along with tasks from the same package. 8633 continue; 8634 } 8635 if (!proc.pkgList.containsKey(pkg)) { 8636 // Don't kill process that is not associated with this task. 8637 continue; 8638 } 8639 8640 for (int k = 0; k < proc.activities.size(); k++) { 8641 TaskRecord otherTask = proc.activities.get(k).task; 8642 if (tr.taskId != otherTask.taskId && otherTask.inRecents) { 8643 // Don't kill process(es) that has an activity in a different task that is 8644 // also in recents. 8645 return; 8646 } 8647 } 8648 8649 if (proc.foregroundServices) { 8650 // Don't kill process(es) with foreground service. 8651 return; 8652 } 8653 8654 // Add process to kill list. 8655 procsToKill.add(proc); 8656 } 8657 } 8658 8659 // Kill the running processes. 8660 for (int i = 0; i < procsToKill.size(); i++) { 8661 ProcessRecord pr = procsToKill.get(i); 8662 if (pr.setSchedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 8663 && pr.curReceiver == null) { 8664 pr.kill("remove task", true); 8665 } else { 8666 // We delay killing processes that are not in the background or running a receiver. 8667 pr.waitingToKill = "remove task"; 8668 } 8669 } 8670 } 8671 8672 private void removeTasksByPackageNameLocked(String packageName, int userId) { 8673 // Remove all tasks with activities in the specified package from the list of recent tasks 8674 for (int i = mRecentTasks.size() - 1; i >= 0; i--) { 8675 TaskRecord tr = mRecentTasks.get(i); 8676 if (tr.userId != userId) continue; 8677 8678 ComponentName cn = tr.intent.getComponent(); 8679 if (cn != null && cn.getPackageName().equals(packageName)) { 8680 // If the package name matches, remove the task. 8681 removeTaskByIdLocked(tr.taskId, true); 8682 } 8683 } 8684 } 8685 8686 private void cleanupDisabledPackageTasksLocked(String packageName, Set<String> filterByClasses, 8687 int userId) { 8688 8689 for (int i = mRecentTasks.size() - 1; i >= 0; i--) { 8690 TaskRecord tr = mRecentTasks.get(i); 8691 if (userId != UserHandle.USER_ALL && tr.userId != userId) { 8692 continue; 8693 } 8694 8695 ComponentName cn = tr.intent.getComponent(); 8696 final boolean sameComponent = cn != null && cn.getPackageName().equals(packageName) 8697 && (filterByClasses == null || filterByClasses.contains(cn.getClassName())); 8698 if (sameComponent) { 8699 removeTaskByIdLocked(tr.taskId, false); 8700 } 8701 } 8702 } 8703 8704 /** 8705 * Removes the task with the specified task id. 8706 * 8707 * @param taskId Identifier of the task to be removed. 8708 * @param killProcess Kill any process associated with the task if possible. 8709 * @return Returns true if the given task was found and removed. 8710 */ 8711 private boolean removeTaskByIdLocked(int taskId, boolean killProcess) { 8712 TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(taskId, false); 8713 if (tr != null) { 8714 tr.removeTaskActivitiesLocked(); 8715 cleanUpRemovedTaskLocked(tr, killProcess); 8716 if (tr.isPersistable) { 8717 notifyTaskPersisterLocked(null, true); 8718 } 8719 return true; 8720 } 8721 Slog.w(TAG, "Request to remove task ignored for non-existent task " + taskId); 8722 return false; 8723 } 8724 8725 @Override 8726 public boolean removeTask(int taskId) { 8727 synchronized (this) { 8728 enforceCallingPermission(android.Manifest.permission.REMOVE_TASKS, 8729 "removeTask()"); 8730 long ident = Binder.clearCallingIdentity(); 8731 try { 8732 return removeTaskByIdLocked(taskId, true); 8733 } finally { 8734 Binder.restoreCallingIdentity(ident); 8735 } 8736 } 8737 } 8738 8739 /** 8740 * TODO: Add mController hook 8741 */ 8742 @Override 8743 public void moveTaskToFront(int taskId, int flags, Bundle options) { 8744 enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, "moveTaskToFront()"); 8745 8746 if (DEBUG_STACK) Slog.d(TAG_STACK, "moveTaskToFront: moving taskId=" + taskId); 8747 synchronized(this) { 8748 moveTaskToFrontLocked(taskId, flags, options); 8749 } 8750 } 8751 8752 void moveTaskToFrontLocked(int taskId, int flags, Bundle options) { 8753 if (!checkAppSwitchAllowedLocked(Binder.getCallingPid(), 8754 Binder.getCallingUid(), -1, -1, "Task to front")) { 8755 ActivityOptions.abort(options); 8756 return; 8757 } 8758 final long origId = Binder.clearCallingIdentity(); 8759 try { 8760 final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId); 8761 if (task == null) { 8762 Slog.d(TAG, "Could not find task for id: "+ taskId); 8763 return; 8764 } 8765 if (mStackSupervisor.isLockTaskModeViolation(task)) { 8766 mStackSupervisor.showLockTaskToast(); 8767 Slog.e(TAG, "moveTaskToFront: Attempt to violate Lock Task Mode"); 8768 return; 8769 } 8770 final ActivityRecord prev = mStackSupervisor.topRunningActivityLocked(); 8771 if (prev != null && prev.isRecentsActivity()) { 8772 task.setTaskToReturnTo(ActivityRecord.RECENTS_ACTIVITY_TYPE); 8773 } 8774 mStackSupervisor.findTaskToMoveToFrontLocked(task, flags, options, "moveTaskToFront"); 8775 } finally { 8776 Binder.restoreCallingIdentity(origId); 8777 } 8778 ActivityOptions.abort(options); 8779 } 8780 8781 /** 8782 * Moves an activity, and all of the other activities within the same task, to the bottom 8783 * of the history stack. The activity's order within the task is unchanged. 8784 * 8785 * @param token A reference to the activity we wish to move 8786 * @param nonRoot If false then this only works if the activity is the root 8787 * of a task; if true it will work for any activity in a task. 8788 * @return Returns true if the move completed, false if not. 8789 */ 8790 @Override 8791 public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) { 8792 enforceNotIsolatedCaller("moveActivityTaskToBack"); 8793 synchronized(this) { 8794 final long origId = Binder.clearCallingIdentity(); 8795 try { 8796 int taskId = ActivityRecord.getTaskForActivityLocked(token, !nonRoot); 8797 final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId); 8798 if (task != null) { 8799 if (mStackSupervisor.isLockedTask(task)) { 8800 mStackSupervisor.showLockTaskToast(); 8801 return false; 8802 } 8803 return ActivityRecord.getStackLocked(token).moveTaskToBackLocked(taskId); 8804 } 8805 } finally { 8806 Binder.restoreCallingIdentity(origId); 8807 } 8808 } 8809 return false; 8810 } 8811 8812 @Override 8813 public void moveTaskBackwards(int task) { 8814 enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, 8815 "moveTaskBackwards()"); 8816 8817 synchronized(this) { 8818 if (!checkAppSwitchAllowedLocked(Binder.getCallingPid(), 8819 Binder.getCallingUid(), -1, -1, "Task backwards")) { 8820 return; 8821 } 8822 final long origId = Binder.clearCallingIdentity(); 8823 moveTaskBackwardsLocked(task); 8824 Binder.restoreCallingIdentity(origId); 8825 } 8826 } 8827 8828 private final void moveTaskBackwardsLocked(int task) { 8829 Slog.e(TAG, "moveTaskBackwards not yet implemented!"); 8830 } 8831 8832 @Override 8833 public IActivityContainer createVirtualActivityContainer(IBinder parentActivityToken, 8834 IActivityContainerCallback callback) throws RemoteException { 8835 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8836 "createActivityContainer()"); 8837 synchronized (this) { 8838 if (parentActivityToken == null) { 8839 throw new IllegalArgumentException("parent token must not be null"); 8840 } 8841 ActivityRecord r = ActivityRecord.forTokenLocked(parentActivityToken); 8842 if (r == null) { 8843 return null; 8844 } 8845 if (callback == null) { 8846 throw new IllegalArgumentException("callback must not be null"); 8847 } 8848 return mStackSupervisor.createVirtualActivityContainer(r, callback); 8849 } 8850 } 8851 8852 @Override 8853 public void deleteActivityContainer(IActivityContainer container) throws RemoteException { 8854 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8855 "deleteActivityContainer()"); 8856 synchronized (this) { 8857 mStackSupervisor.deleteActivityContainer(container); 8858 } 8859 } 8860 8861 @Override 8862 public IActivityContainer createStackOnDisplay(int displayId) throws RemoteException { 8863 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8864 "createStackOnDisplay()"); 8865 synchronized (this) { 8866 final int stackId = mStackSupervisor.getNextStackId(); 8867 final ActivityStack stack = mStackSupervisor.createStackOnDisplay(stackId, displayId); 8868 if (stack == null) { 8869 return null; 8870 } 8871 return stack.mActivityContainer; 8872 } 8873 } 8874 8875 @Override 8876 public int getActivityDisplayId(IBinder activityToken) throws RemoteException { 8877 synchronized (this) { 8878 ActivityStack stack = ActivityRecord.getStackLocked(activityToken); 8879 if (stack != null && stack.mActivityContainer.isAttachedLocked()) { 8880 return stack.mActivityContainer.getDisplayId(); 8881 } 8882 return Display.DEFAULT_DISPLAY; 8883 } 8884 } 8885 8886 @Override 8887 public void moveTaskToStack(int taskId, int stackId, boolean toTop) { 8888 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8889 "moveTaskToStack()"); 8890 if (stackId == HOME_STACK_ID) { 8891 Slog.e(TAG, "moveTaskToStack: Attempt to move task " + taskId + " to home stack", 8892 new RuntimeException("here").fillInStackTrace()); 8893 } 8894 synchronized (this) { 8895 long ident = Binder.clearCallingIdentity(); 8896 try { 8897 if (DEBUG_STACK) Slog.d(TAG_STACK, "moveTaskToStack: moving task=" + taskId 8898 + " to stackId=" + stackId + " toTop=" + toTop); 8899 mStackSupervisor.moveTaskToStackLocked(taskId, stackId, toTop); 8900 } finally { 8901 Binder.restoreCallingIdentity(ident); 8902 } 8903 } 8904 } 8905 8906 @Override 8907 public void resizeStack(int stackId, Rect bounds) { 8908 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8909 "resizeStack()"); 8910 long ident = Binder.clearCallingIdentity(); 8911 try { 8912 synchronized (this) { 8913 mStackSupervisor.resizeStackLocked(stackId, bounds); 8914 } 8915 } finally { 8916 Binder.restoreCallingIdentity(ident); 8917 } 8918 } 8919 8920 @Override 8921 public List<StackInfo> getAllStackInfos() { 8922 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8923 "getAllStackInfos()"); 8924 long ident = Binder.clearCallingIdentity(); 8925 try { 8926 synchronized (this) { 8927 return mStackSupervisor.getAllStackInfosLocked(); 8928 } 8929 } finally { 8930 Binder.restoreCallingIdentity(ident); 8931 } 8932 } 8933 8934 @Override 8935 public StackInfo getStackInfo(int stackId) { 8936 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8937 "getStackInfo()"); 8938 long ident = Binder.clearCallingIdentity(); 8939 try { 8940 synchronized (this) { 8941 return mStackSupervisor.getStackInfoLocked(stackId); 8942 } 8943 } finally { 8944 Binder.restoreCallingIdentity(ident); 8945 } 8946 } 8947 8948 @Override 8949 public boolean isInHomeStack(int taskId) { 8950 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 8951 "getStackInfo()"); 8952 long ident = Binder.clearCallingIdentity(); 8953 try { 8954 synchronized (this) { 8955 TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(taskId, false); 8956 return tr != null && tr.stack != null && tr.stack.isHomeStack(); 8957 } 8958 } finally { 8959 Binder.restoreCallingIdentity(ident); 8960 } 8961 } 8962 8963 @Override 8964 public int getTaskForActivity(IBinder token, boolean onlyRoot) { 8965 synchronized(this) { 8966 return ActivityRecord.getTaskForActivityLocked(token, onlyRoot); 8967 } 8968 } 8969 8970 @Override 8971 public void updateDeviceOwner(String packageName) { 8972 final int callingUid = Binder.getCallingUid(); 8973 if (callingUid != 0 && callingUid != Process.SYSTEM_UID) { 8974 throw new SecurityException("updateDeviceOwner called from non-system process"); 8975 } 8976 synchronized (this) { 8977 mDeviceOwnerName = packageName; 8978 } 8979 } 8980 8981 @Override 8982 public void updateLockTaskPackages(int userId, String[] packages) { 8983 final int callingUid = Binder.getCallingUid(); 8984 if (callingUid != 0 && callingUid != Process.SYSTEM_UID) { 8985 throw new SecurityException("updateLockTaskPackage called from non-system process"); 8986 } 8987 synchronized (this) { 8988 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "Whitelisting " + userId + ":" + 8989 Arrays.toString(packages)); 8990 mLockTaskPackages.put(userId, packages); 8991 mStackSupervisor.onLockTaskPackagesUpdatedLocked(); 8992 } 8993 } 8994 8995 8996 void startLockTaskModeLocked(TaskRecord task) { 8997 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "startLockTaskModeLocked: " + task); 8998 if (task.mLockTaskAuth == LOCK_TASK_AUTH_DONT_LOCK) { 8999 return; 9000 } 9001 9002 // isSystemInitiated is used to distinguish between locked and pinned mode, as pinned mode 9003 // is initiated by system after the pinning request was shown and locked mode is initiated 9004 // by an authorized app directly 9005 final int callingUid = Binder.getCallingUid(); 9006 boolean isSystemInitiated = callingUid == Process.SYSTEM_UID; 9007 long ident = Binder.clearCallingIdentity(); 9008 try { 9009 final ActivityStack stack = mStackSupervisor.getFocusedStack(); 9010 if (!isSystemInitiated) { 9011 task.mLockTaskUid = callingUid; 9012 if (task.mLockTaskAuth == LOCK_TASK_AUTH_PINNABLE) { 9013 // startLockTask() called by app and task mode is lockTaskModeDefault. 9014 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, "Mode default, asking user"); 9015 StatusBarManagerInternal statusBarManager = 9016 LocalServices.getService(StatusBarManagerInternal.class); 9017 if (statusBarManager != null) { 9018 statusBarManager.showScreenPinningRequest(); 9019 } 9020 return; 9021 } 9022 9023 if (stack == null || task != stack.topTask()) { 9024 throw new IllegalArgumentException("Invalid task, not in foreground"); 9025 } 9026 } 9027 if (DEBUG_LOCKTASK) Slog.w(TAG_LOCKTASK, isSystemInitiated ? "Locking pinned" : 9028 "Locking fully"); 9029 mStackSupervisor.setLockTaskModeLocked(task, isSystemInitiated ? 9030 ActivityManager.LOCK_TASK_MODE_PINNED : 9031 ActivityManager.LOCK_TASK_MODE_LOCKED, 9032 "startLockTask", true); 9033 } finally { 9034 Binder.restoreCallingIdentity(ident); 9035 } 9036 } 9037 9038 @Override 9039 public void startLockTaskMode(int taskId) { 9040 synchronized (this) { 9041 final TaskRecord task = mStackSupervisor.anyTaskForIdLocked(taskId); 9042 if (task != null) { 9043 startLockTaskModeLocked(task); 9044 } 9045 } 9046 } 9047 9048 @Override 9049 public void startLockTaskMode(IBinder token) { 9050 synchronized (this) { 9051 final ActivityRecord r = ActivityRecord.forTokenLocked(token); 9052 if (r == null) { 9053 return; 9054 } 9055 final TaskRecord task = r.task; 9056 if (task != null) { 9057 startLockTaskModeLocked(task); 9058 } 9059 } 9060 } 9061 9062 @Override 9063 public void startLockTaskModeOnCurrent() throws RemoteException { 9064 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 9065 "startLockTaskModeOnCurrent"); 9066 long ident = Binder.clearCallingIdentity(); 9067 try { 9068 synchronized (this) { 9069 ActivityRecord r = mStackSupervisor.topRunningActivityLocked(); 9070 if (r != null) { 9071 startLockTaskModeLocked(r.task); 9072 } 9073 } 9074 } finally { 9075 Binder.restoreCallingIdentity(ident); 9076 } 9077 } 9078 9079 @Override 9080 public void stopLockTaskMode() { 9081 final TaskRecord lockTask = mStackSupervisor.getLockedTaskLocked(); 9082 if (lockTask == null) { 9083 // Our work here is done. 9084 return; 9085 } 9086 9087 final int callingUid = Binder.getCallingUid(); 9088 final int lockTaskUid = lockTask.mLockTaskUid; 9089 // Ensure the same caller for startLockTaskMode and stopLockTaskMode. 9090 // It is possible lockTaskMode was started by the system process because 9091 // android:lockTaskMode is set to a locking value in the application manifest instead of 9092 // the app calling startLockTaskMode. In this case {@link TaskRecord.mLockTaskUid} will 9093 // be 0, so we compare the callingUid to the {@link TaskRecord.effectiveUid} instead. 9094 if (getLockTaskModeState() == ActivityManager.LOCK_TASK_MODE_LOCKED && 9095 callingUid != lockTaskUid 9096 && (lockTaskUid != 0 9097 || (lockTaskUid == 0 && callingUid != lockTask.effectiveUid))) { 9098 throw new SecurityException("Invalid uid, expected " + lockTaskUid 9099 + " callingUid=" + callingUid + " effectiveUid=" + lockTask.effectiveUid); 9100 } 9101 9102 long ident = Binder.clearCallingIdentity(); 9103 try { 9104 Log.d(TAG, "stopLockTaskMode"); 9105 // Stop lock task 9106 synchronized (this) { 9107 mStackSupervisor.setLockTaskModeLocked(null, ActivityManager.LOCK_TASK_MODE_NONE, 9108 "stopLockTask", true); 9109 } 9110 } finally { 9111 Binder.restoreCallingIdentity(ident); 9112 } 9113 } 9114 9115 @Override 9116 public void stopLockTaskModeOnCurrent() throws RemoteException { 9117 enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, 9118 "stopLockTaskModeOnCurrent"); 9119 long ident = Binder.clearCallingIdentity(); 9120 try { 9121 stopLockTaskMode(); 9122 } finally { 9123 Binder.restoreCallingIdentity(ident); 9124 } 9125 } 9126 9127 @Override 9128 public boolean isInLockTaskMode() { 9129 return getLockTaskModeState() != ActivityManager.LOCK_TASK_MODE_NONE; 9130 } 9131 9132 @Override 9133 public int getLockTaskModeState() { 9134 synchronized (this) { 9135 return mStackSupervisor.getLockTaskModeState(); 9136 } 9137 } 9138 9139 @Override 9140 public void showLockTaskEscapeMessage(IBinder token) { 9141 synchronized (this) { 9142 final ActivityRecord r = ActivityRecord.forTokenLocked(token); 9143 if (r == null) { 9144 return; 9145 } 9146 mStackSupervisor.showLockTaskEscapeMessageLocked(r.task); 9147 } 9148 } 9149 9150 // ========================================================= 9151 // CONTENT PROVIDERS 9152 // ========================================================= 9153 9154 private final List<ProviderInfo> generateApplicationProvidersLocked(ProcessRecord app) { 9155 List<ProviderInfo> providers = null; 9156 try { 9157 ParceledListSlice<ProviderInfo> slice = AppGlobals.getPackageManager(). 9158 queryContentProviders(app.processName, app.uid, 9159 STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS); 9160 providers = slice != null ? slice.getList() : null; 9161 } catch (RemoteException ex) { 9162 } 9163 if (DEBUG_MU) Slog.v(TAG_MU, 9164 "generateApplicationProvidersLocked, app.info.uid = " + app.uid); 9165 int userId = app.userId; 9166 if (providers != null) { 9167 int N = providers.size(); 9168 app.pubProviders.ensureCapacity(N + app.pubProviders.size()); 9169 for (int i=0; i<N; i++) { 9170 ProviderInfo cpi = 9171 (ProviderInfo)providers.get(i); 9172 boolean singleton = isSingleton(cpi.processName, cpi.applicationInfo, 9173 cpi.name, cpi.flags); 9174 if (singleton && UserHandle.getUserId(app.uid) != UserHandle.USER_OWNER) { 9175 // This is a singleton provider, but a user besides the 9176 // default user is asking to initialize a process it runs 9177 // in... well, no, it doesn't actually run in this process, 9178 // it runs in the process of the default user. Get rid of it. 9179 providers.remove(i); 9180 N--; 9181 i--; 9182 continue; 9183 } 9184 9185 ComponentName comp = new ComponentName(cpi.packageName, cpi.name); 9186 ContentProviderRecord cpr = mProviderMap.getProviderByClass(comp, userId); 9187 if (cpr == null) { 9188 cpr = new ContentProviderRecord(this, cpi, app.info, comp, singleton); 9189 mProviderMap.putProviderByClass(comp, cpr); 9190 } 9191 if (DEBUG_MU) Slog.v(TAG_MU, 9192 "generateApplicationProvidersLocked, cpi.uid = " + cpr.uid); 9193 app.pubProviders.put(cpi.name, cpr); 9194 if (!cpi.multiprocess || !"android".equals(cpi.packageName)) { 9195 // Don't add this if it is a platform component that is marked 9196 // to run in multiple processes, because this is actually 9197 // part of the framework so doesn't make sense to track as a 9198 // separate apk in the process. 9199 app.addPackage(cpi.applicationInfo.packageName, cpi.applicationInfo.versionCode, 9200 mProcessStats); 9201 } 9202 ensurePackageDexOpt(cpi.applicationInfo.packageName); 9203 } 9204 } 9205 return providers; 9206 } 9207 9208 /** 9209 * Check if {@link ProcessRecord} has a possible chance at accessing the 9210 * given {@link ProviderInfo}. Final permission checking is always done 9211 * in {@link ContentProvider}. 9212 */ 9213 private final String checkContentProviderPermissionLocked( 9214 ProviderInfo cpi, ProcessRecord r, int userId, boolean checkUser) { 9215 final int callingPid = (r != null) ? r.pid : Binder.getCallingPid(); 9216 final int callingUid = (r != null) ? r.uid : Binder.getCallingUid(); 9217 boolean checkedGrants = false; 9218 if (checkUser) { 9219 // Looking for cross-user grants before enforcing the typical cross-users permissions 9220 int tmpTargetUserId = unsafeConvertIncomingUser(userId); 9221 if (tmpTargetUserId != UserHandle.getUserId(callingUid)) { 9222 if (checkAuthorityGrants(callingUid, cpi, tmpTargetUserId, checkUser)) { 9223 return null; 9224 } 9225 checkedGrants = true; 9226 } 9227 userId = handleIncomingUser(callingPid, callingUid, userId, 9228 false, ALLOW_NON_FULL, 9229 "checkContentProviderPermissionLocked " + cpi.authority, null); 9230 if (userId != tmpTargetUserId) { 9231 // When we actually went to determine the final targer user ID, this ended 9232 // up different than our initial check for the authority. This is because 9233 // they had asked for USER_CURRENT_OR_SELF and we ended up switching to 9234 // SELF. So we need to re-check the grants again. 9235 checkedGrants = false; 9236 } 9237 } 9238 if (checkComponentPermission(cpi.readPermission, callingPid, callingUid, 9239 cpi.applicationInfo.uid, cpi.exported) 9240 == PackageManager.PERMISSION_GRANTED) { 9241 return null; 9242 } 9243 if (checkComponentPermission(cpi.writePermission, callingPid, callingUid, 9244 cpi.applicationInfo.uid, cpi.exported) 9245 == PackageManager.PERMISSION_GRANTED) { 9246 return null; 9247 } 9248 9249 PathPermission[] pps = cpi.pathPermissions; 9250 if (pps != null) { 9251 int i = pps.length; 9252 while (i > 0) { 9253 i--; 9254 PathPermission pp = pps[i]; 9255 String pprperm = pp.getReadPermission(); 9256 if (pprperm != null && checkComponentPermission(pprperm, callingPid, callingUid, 9257 cpi.applicationInfo.uid, cpi.exported) 9258 == PackageManager.PERMISSION_GRANTED) { 9259 return null; 9260 } 9261 String ppwperm = pp.getWritePermission(); 9262 if (ppwperm != null && checkComponentPermission(ppwperm, callingPid, callingUid, 9263 cpi.applicationInfo.uid, cpi.exported) 9264 == PackageManager.PERMISSION_GRANTED) { 9265 return null; 9266 } 9267 } 9268 } 9269 if (!checkedGrants && checkAuthorityGrants(callingUid, cpi, userId, checkUser)) { 9270 return null; 9271 } 9272 9273 String msg; 9274 if (!cpi.exported) { 9275 msg = "Permission Denial: opening provider " + cpi.name 9276 + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid 9277 + ", uid=" + callingUid + ") that is not exported from uid " 9278 + cpi.applicationInfo.uid; 9279 } else { 9280 msg = "Permission Denial: opening provider " + cpi.name 9281 + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid 9282 + ", uid=" + callingUid + ") requires " 9283 + cpi.readPermission + " or " + cpi.writePermission; 9284 } 9285 Slog.w(TAG, msg); 9286 return msg; 9287 } 9288 9289 /** 9290 * Returns if the ContentProvider has granted a uri to callingUid 9291 */ 9292 boolean checkAuthorityGrants(int callingUid, ProviderInfo cpi, int userId, boolean checkUser) { 9293 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.get(callingUid); 9294 if (perms != null) { 9295 for (int i=perms.size()-1; i>=0; i--) { 9296 GrantUri grantUri = perms.keyAt(i); 9297 if (grantUri.sourceUserId == userId || !checkUser) { 9298 if (matchesProvider(grantUri.uri, cpi)) { 9299 return true; 9300 } 9301 } 9302 } 9303 } 9304 return false; 9305 } 9306 9307 /** 9308 * Returns true if the uri authority is one of the authorities specified in the provider. 9309 */ 9310 boolean matchesProvider(Uri uri, ProviderInfo cpi) { 9311 String uriAuth = uri.getAuthority(); 9312 String cpiAuth = cpi.authority; 9313 if (cpiAuth.indexOf(';') == -1) { 9314 return cpiAuth.equals(uriAuth); 9315 } 9316 String[] cpiAuths = cpiAuth.split(";"); 9317 int length = cpiAuths.length; 9318 for (int i = 0; i < length; i++) { 9319 if (cpiAuths[i].equals(uriAuth)) return true; 9320 } 9321 return false; 9322 } 9323 9324 ContentProviderConnection incProviderCountLocked(ProcessRecord r, 9325 final ContentProviderRecord cpr, IBinder externalProcessToken, boolean stable) { 9326 if (r != null) { 9327 for (int i=0; i<r.conProviders.size(); i++) { 9328 ContentProviderConnection conn = r.conProviders.get(i); 9329 if (conn.provider == cpr) { 9330 if (DEBUG_PROVIDER) Slog.v(TAG_PROVIDER, 9331 "Adding provider requested by " 9332 + r.processName + " from process " 9333 + cpr.info.processName + ": " + cpr.name.flattenToShortString() 9334 + " scnt=" + conn.stableCount + " uscnt=" + conn.unstableCount); 9335 if (stable) { 9336 conn.stableCount++; 9337 conn.numStableIncs++; 9338 } else { 9339 conn.unstableCount++; 9340 conn.numUnstableIncs++; 9341 } 9342 return conn; 9343 } 9344 } 9345 ContentProviderConnection conn = new ContentProviderConnection(cpr, r); 9346 if (stable) { 9347 conn.stableCount = 1; 9348 conn.numStableIncs = 1; 9349 } else { 9350 conn.unstableCount = 1; 9351 conn.numUnstableIncs = 1; 9352 } 9353 cpr.connections.add(conn); 9354 r.conProviders.add(conn); 9355 startAssociationLocked(r.uid, r.processName, cpr.uid, cpr.name, cpr.info.processName); 9356 return conn; 9357 } 9358 cpr.addExternalProcessHandleLocked(externalProcessToken); 9359 return null; 9360 } 9361 9362 boolean decProviderCountLocked(ContentProviderConnection conn, 9363 ContentProviderRecord cpr, IBinder externalProcessToken, boolean stable) { 9364 if (conn != null) { 9365 cpr = conn.provider; 9366 if (DEBUG_PROVIDER) Slog.v(TAG_PROVIDER, 9367 "Removing provider requested by " 9368 + conn.client.processName + " from process " 9369 + cpr.info.processName + ": " + cpr.name.flattenToShortString() 9370 + " scnt=" + conn.stableCount + " uscnt=" + conn.unstableCount); 9371 if (stable) { 9372 conn.stableCount--; 9373 } else { 9374 conn.unstableCount--; 9375 } 9376 if (conn.stableCount == 0 && conn.unstableCount == 0) { 9377 cpr.connections.remove(conn); 9378 conn.client.conProviders.remove(conn); 9379 stopAssociationLocked(conn.client.uid, conn.client.processName, cpr.uid, cpr.name); 9380 return true; 9381 } 9382 return false; 9383 } 9384 cpr.removeExternalProcessHandleLocked(externalProcessToken); 9385 return false; 9386 } 9387 9388 private void checkTime(long startTime, String where) { 9389 long now = SystemClock.elapsedRealtime(); 9390 if ((now-startTime) > 1000) { 9391 // If we are taking more than a second, log about it. 9392 Slog.w(TAG, "Slow operation: " + (now-startTime) + "ms so far, now at " + where); 9393 } 9394 } 9395 9396 private final ContentProviderHolder getContentProviderImpl(IApplicationThread caller, 9397 String name, IBinder token, boolean stable, int userId) { 9398 ContentProviderRecord cpr; 9399 ContentProviderConnection conn = null; 9400 ProviderInfo cpi = null; 9401 9402 synchronized(this) { 9403 long startTime = SystemClock.elapsedRealtime(); 9404 9405 ProcessRecord r = null; 9406 if (caller != null) { 9407 r = getRecordForAppLocked(caller); 9408 if (r == null) { 9409 throw new SecurityException( 9410 "Unable to find app for caller " + caller 9411 + " (pid=" + Binder.getCallingPid() 9412 + ") when getting content provider " + name); 9413 } 9414 } 9415 9416 boolean checkCrossUser = true; 9417 9418 checkTime(startTime, "getContentProviderImpl: getProviderByName"); 9419 9420 // First check if this content provider has been published... 9421 cpr = mProviderMap.getProviderByName(name, userId); 9422 // If that didn't work, check if it exists for user 0 and then 9423 // verify that it's a singleton provider before using it. 9424 if (cpr == null && userId != UserHandle.USER_OWNER) { 9425 cpr = mProviderMap.getProviderByName(name, UserHandle.USER_OWNER); 9426 if (cpr != null) { 9427 cpi = cpr.info; 9428 if (isSingleton(cpi.processName, cpi.applicationInfo, 9429 cpi.name, cpi.flags) 9430 && isValidSingletonCall(r.uid, cpi.applicationInfo.uid)) { 9431 userId = UserHandle.USER_OWNER; 9432 checkCrossUser = false; 9433 } else { 9434 cpr = null; 9435 cpi = null; 9436 } 9437 } 9438 } 9439 9440 boolean providerRunning = cpr != null; 9441 if (providerRunning) { 9442 cpi = cpr.info; 9443 String msg; 9444 checkTime(startTime, "getContentProviderImpl: before checkContentProviderPermission"); 9445 if ((msg = checkContentProviderPermissionLocked(cpi, r, userId, checkCrossUser)) 9446 != null) { 9447 throw new SecurityException(msg); 9448 } 9449 checkTime(startTime, "getContentProviderImpl: after checkContentProviderPermission"); 9450 9451 if (r != null && cpr.canRunHere(r)) { 9452 // This provider has been published or is in the process 9453 // of being published... but it is also allowed to run 9454 // in the caller's process, so don't make a connection 9455 // and just let the caller instantiate its own instance. 9456 ContentProviderHolder holder = cpr.newHolder(null); 9457 // don't give caller the provider object, it needs 9458 // to make its own. 9459 holder.provider = null; 9460 return holder; 9461 } 9462 9463 final long origId = Binder.clearCallingIdentity(); 9464 9465 checkTime(startTime, "getContentProviderImpl: incProviderCountLocked"); 9466 9467 // In this case the provider instance already exists, so we can 9468 // return it right away. 9469 conn = incProviderCountLocked(r, cpr, token, stable); 9470 if (conn != null && (conn.stableCount+conn.unstableCount) == 1) { 9471 if (cpr.proc != null && r.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ) { 9472 // If this is a perceptible app accessing the provider, 9473 // make sure to count it as being accessed and thus 9474 // back up on the LRU list. This is good because 9475 // content providers are often expensive to start. 9476 checkTime(startTime, "getContentProviderImpl: before updateLruProcess"); 9477 updateLruProcessLocked(cpr.proc, false, null); 9478 checkTime(startTime, "getContentProviderImpl: after updateLruProcess"); 9479 } 9480 } 9481 9482 if (cpr.proc != null) { 9483 if (false) { 9484 if (cpr.name.flattenToShortString().equals( 9485 "com.android.providers.calendar/.CalendarProvider2")) { 9486 Slog.v(TAG, "****************** KILLING " 9487 + cpr.name.flattenToShortString()); 9488 Process.killProcess(cpr.proc.pid); 9489 } 9490 } 9491 checkTime(startTime, "getContentProviderImpl: before updateOomAdj"); 9492 boolean success = updateOomAdjLocked(cpr.proc); 9493 maybeUpdateProviderUsageStatsLocked(r, cpr.info.packageName, name); 9494 checkTime(startTime, "getContentProviderImpl: after updateOomAdj"); 9495 if (DEBUG_PROVIDER) Slog.i(TAG_PROVIDER, "Adjust success: " + success); 9496 // NOTE: there is still a race here where a signal could be 9497 // pending on the process even though we managed to update its 9498 // adj level. Not sure what to do about this, but at least 9499 // the race is now smaller. 9500 if (!success) { 9501 // Uh oh... it looks like the provider's process 9502 // has been killed on us. We need to wait for a new 9503 // process to be started, and make sure its death 9504 // doesn't kill our process. 9505 Slog.i(TAG, "Existing provider " + cpr.name.flattenToShortString() 9506 + " is crashing; detaching " + r); 9507 boolean lastRef = decProviderCountLocked(conn, cpr, token, stable); 9508 checkTime(startTime, "getContentProviderImpl: before appDied"); 9509 appDiedLocked(cpr.proc); 9510 checkTime(startTime, "getContentProviderImpl: after appDied"); 9511 if (!lastRef) { 9512 // This wasn't the last ref our process had on 9513 // the provider... we have now been killed, bail. 9514 return null; 9515 } 9516 providerRunning = false; 9517 conn = null; 9518 } 9519 } 9520 9521 Binder.restoreCallingIdentity(origId); 9522 } 9523 9524 boolean singleton; 9525 if (!providerRunning) { 9526 try { 9527 checkTime(startTime, "getContentProviderImpl: before resolveContentProvider"); 9528 cpi = AppGlobals.getPackageManager(). 9529 resolveContentProvider(name, 9530 STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS, userId); 9531 checkTime(startTime, "getContentProviderImpl: after resolveContentProvider"); 9532 } catch (RemoteException ex) { 9533 } 9534 if (cpi == null) { 9535 return null; 9536 } 9537 // If the provider is a singleton AND 9538 // (it's a call within the same user || the provider is a 9539 // privileged app) 9540 // Then allow connecting to the singleton provider 9541 singleton = isSingleton(cpi.processName, cpi.applicationInfo, 9542 cpi.name, cpi.flags) 9543 && isValidSingletonCall(r.uid, cpi.applicationInfo.uid); 9544 if (singleton) { 9545 userId = UserHandle.USER_OWNER; 9546 } 9547 cpi.applicationInfo = getAppInfoForUser(cpi.applicationInfo, userId); 9548 checkTime(startTime, "getContentProviderImpl: got app info for user"); 9549 9550 String msg; 9551 checkTime(startTime, "getContentProviderImpl: before checkContentProviderPermission"); 9552 if ((msg = checkContentProviderPermissionLocked(cpi, r, userId, !singleton)) 9553 != null) { 9554 throw new SecurityException(msg); 9555 } 9556 checkTime(startTime, "getContentProviderImpl: after checkContentProviderPermission"); 9557 9558 if (!mProcessesReady && !mDidUpdate && !mWaitingUpdate 9559 && !cpi.processName.equals("system")) { 9560 // If this content provider does not run in the system 9561 // process, and the system is not yet ready to run other 9562 // processes, then fail fast instead of hanging. 9563 throw new IllegalArgumentException( 9564 "Attempt to launch content provider before system ready"); 9565 } 9566 9567 // Make sure that the user who owns this provider is running. If not, 9568 // we don't want to allow it to run. 9569 if (!isUserRunningLocked(userId, false)) { 9570 Slog.w(TAG, "Unable to launch app " 9571 + cpi.applicationInfo.packageName + "/" 9572 + cpi.applicationInfo.uid + " for provider " 9573 + name + ": user " + userId + " is stopped"); 9574 return null; 9575 } 9576 9577 ComponentName comp = new ComponentName(cpi.packageName, cpi.name); 9578 checkTime(startTime, "getContentProviderImpl: before getProviderByClass"); 9579 cpr = mProviderMap.getProviderByClass(comp, userId); 9580 checkTime(startTime, "getContentProviderImpl: after getProviderByClass"); 9581 final boolean firstClass = cpr == null; 9582 if (firstClass) { 9583 final long ident = Binder.clearCallingIdentity(); 9584 try { 9585 checkTime(startTime, "getContentProviderImpl: before getApplicationInfo"); 9586 ApplicationInfo ai = 9587 AppGlobals.getPackageManager(). 9588 getApplicationInfo( 9589 cpi.applicationInfo.packageName, 9590 STOCK_PM_FLAGS, userId); 9591 checkTime(startTime, "getContentProviderImpl: after getApplicationInfo"); 9592 if (ai == null) { 9593 Slog.w(TAG, "No package info for content provider " 9594 + cpi.name); 9595 return null; 9596 } 9597 ai = getAppInfoForUser(ai, userId); 9598 cpr = new ContentProviderRecord(this, cpi, ai, comp, singleton); 9599 } catch (RemoteException ex) { 9600 // pm is in same process, this will never happen. 9601 } finally { 9602 Binder.restoreCallingIdentity(ident); 9603 } 9604 } 9605 9606 checkTime(startTime, "getContentProviderImpl: now have ContentProviderRecord"); 9607 9608 if (r != null && cpr.canRunHere(r)) { 9609 // If this is a multiprocess provider, then just return its 9610 // info and allow the caller to instantiate it. Only do 9611 // this if the provider is the same user as the caller's 9612 // process, or can run as root (so can be in any process). 9613 return cpr.newHolder(null); 9614 } 9615 9616 if (DEBUG_PROVIDER) Slog.w(TAG_PROVIDER, "LAUNCHING REMOTE PROVIDER (myuid " 9617 + (r != null ? r.uid : null) + " pruid " + cpr.appInfo.uid + "): " 9618 + cpr.info.name + " callers=" + Debug.getCallers(6)); 9619 9620 // This is single process, and our app is now connecting to it. 9621 // See if we are already in the process of launching this 9622 // provider. 9623 final int N = mLaunchingProviders.size(); 9624 int i; 9625 for (i = 0; i < N; i++) { 9626 if (mLaunchingProviders.get(i) == cpr) { 9627 break; 9628 } 9629 } 9630 9631 // If the provider is not already being launched, then get it 9632 // started. 9633 if (i >= N) { 9634 final long origId = Binder.clearCallingIdentity(); 9635 9636 try { 9637 // Content provider is now in use, its package can't be stopped. 9638 try { 9639 checkTime(startTime, "getContentProviderImpl: before set stopped state"); 9640 AppGlobals.getPackageManager().setPackageStoppedState( 9641 cpr.appInfo.packageName, false, userId); 9642 checkTime(startTime, "getContentProviderImpl: after set stopped state"); 9643 } catch (RemoteException e) { 9644 } catch (IllegalArgumentException e) { 9645 Slog.w(TAG, "Failed trying to unstop package " 9646 + cpr.appInfo.packageName + ": " + e); 9647 } 9648 9649 // Use existing process if already started 9650 checkTime(startTime, "getContentProviderImpl: looking for process record"); 9651 ProcessRecord proc = getProcessRecordLocked( 9652 cpi.processName, cpr.appInfo.uid, false); 9653 if (proc != null && proc.thread != null) { 9654 if (DEBUG_PROVIDER) Slog.d(TAG_PROVIDER, 9655 "Installing in existing process " + proc); 9656 if (!proc.pubProviders.containsKey(cpi.name)) { 9657 checkTime(startTime, "getContentProviderImpl: scheduling install"); 9658 proc.pubProviders.put(cpi.name, cpr); 9659 try { 9660 proc.thread.scheduleInstallProvider(cpi); 9661 } catch (RemoteException e) { 9662 } 9663 } 9664 } else { 9665 checkTime(startTime, "getContentProviderImpl: before start process"); 9666 proc = startProcessLocked(cpi.processName, 9667 cpr.appInfo, false, 0, "content provider", 9668 new ComponentName(cpi.applicationInfo.packageName, 9669 cpi.name), false, false, false); 9670 checkTime(startTime, "getContentProviderImpl: after start process"); 9671 if (proc == null) { 9672 Slog.w(TAG, "Unable to launch app " 9673 + cpi.applicationInfo.packageName + "/" 9674 + cpi.applicationInfo.uid + " for provider " 9675 + name + ": process is bad"); 9676 return null; 9677 } 9678 } 9679 cpr.launchingApp = proc; 9680 mLaunchingProviders.add(cpr); 9681 } finally { 9682 Binder.restoreCallingIdentity(origId); 9683 } 9684 } 9685 9686 checkTime(startTime, "getContentProviderImpl: updating data structures"); 9687 9688 // Make sure the provider is published (the same provider class 9689 // may be published under multiple names). 9690 if (firstClass) { 9691 mProviderMap.putProviderByClass(comp, cpr); 9692 } 9693 9694 mProviderMap.putProviderByName(name, cpr); 9695 conn = incProviderCountLocked(r, cpr, token, stable); 9696 if (conn != null) { 9697 conn.waiting = true; 9698 } 9699 } 9700 checkTime(startTime, "getContentProviderImpl: done!"); 9701 } 9702 9703 // Wait for the provider to be published... 9704 synchronized (cpr) { 9705 while (cpr.provider == null) { 9706 if (cpr.launchingApp == null) { 9707 Slog.w(TAG, "Unable to launch app " 9708 + cpi.applicationInfo.packageName + "/" 9709 + cpi.applicationInfo.uid + " for provider " 9710 + name + ": launching app became null"); 9711 EventLog.writeEvent(EventLogTags.AM_PROVIDER_LOST_PROCESS, 9712 UserHandle.getUserId(cpi.applicationInfo.uid), 9713 cpi.applicationInfo.packageName, 9714 cpi.applicationInfo.uid, name); 9715 return null; 9716 } 9717 try { 9718 if (DEBUG_MU) Slog.v(TAG_MU, 9719 "Waiting to start provider " + cpr 9720 + " launchingApp=" + cpr.launchingApp); 9721 if (conn != null) { 9722 conn.waiting = true; 9723 } 9724 cpr.wait(); 9725 } catch (InterruptedException ex) { 9726 } finally { 9727 if (conn != null) { 9728 conn.waiting = false; 9729 } 9730 } 9731 } 9732 } 9733 return cpr != null ? cpr.newHolder(conn) : null; 9734 } 9735 9736 @Override 9737 public final ContentProviderHolder getContentProvider( 9738 IApplicationThread caller, String name, int userId, boolean stable) { 9739 enforceNotIsolatedCaller("getContentProvider"); 9740 if (caller == null) { 9741 String msg = "null IApplicationThread when getting content provider " 9742 + name; 9743 Slog.w(TAG, msg); 9744 throw new SecurityException(msg); 9745 } 9746 // The incoming user check is now handled in checkContentProviderPermissionLocked() to deal 9747 // with cross-user grant. 9748 return getContentProviderImpl(caller, name, null, stable, userId); 9749 } 9750 9751 public ContentProviderHolder getContentProviderExternal( 9752 String name, int userId, IBinder token) { 9753 enforceCallingPermission(android.Manifest.permission.ACCESS_CONTENT_PROVIDERS_EXTERNALLY, 9754 "Do not have permission in call getContentProviderExternal()"); 9755 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), userId, 9756 false, ALLOW_FULL_ONLY, "getContentProvider", null); 9757 return getContentProviderExternalUnchecked(name, token, userId); 9758 } 9759 9760 private ContentProviderHolder getContentProviderExternalUnchecked(String name, 9761 IBinder token, int userId) { 9762 return getContentProviderImpl(null, name, token, true, userId); 9763 } 9764 9765 /** 9766 * Drop a content provider from a ProcessRecord's bookkeeping 9767 */ 9768 public void removeContentProvider(IBinder connection, boolean stable) { 9769 enforceNotIsolatedCaller("removeContentProvider"); 9770 long ident = Binder.clearCallingIdentity(); 9771 try { 9772 synchronized (this) { 9773 ContentProviderConnection conn; 9774 try { 9775 conn = (ContentProviderConnection)connection; 9776 } catch (ClassCastException e) { 9777 String msg ="removeContentProvider: " + connection 9778 + " not a ContentProviderConnection"; 9779 Slog.w(TAG, msg); 9780 throw new IllegalArgumentException(msg); 9781 } 9782 if (conn == null) { 9783 throw new NullPointerException("connection is null"); 9784 } 9785 if (decProviderCountLocked(conn, null, null, stable)) { 9786 updateOomAdjLocked(); 9787 } 9788 } 9789 } finally { 9790 Binder.restoreCallingIdentity(ident); 9791 } 9792 } 9793 9794 public void removeContentProviderExternal(String name, IBinder token) { 9795 enforceCallingPermission(android.Manifest.permission.ACCESS_CONTENT_PROVIDERS_EXTERNALLY, 9796 "Do not have permission in call removeContentProviderExternal()"); 9797 int userId = UserHandle.getCallingUserId(); 9798 long ident = Binder.clearCallingIdentity(); 9799 try { 9800 removeContentProviderExternalUnchecked(name, token, userId); 9801 } finally { 9802 Binder.restoreCallingIdentity(ident); 9803 } 9804 } 9805 9806 private void removeContentProviderExternalUnchecked(String name, IBinder token, int userId) { 9807 synchronized (this) { 9808 ContentProviderRecord cpr = mProviderMap.getProviderByName(name, userId); 9809 if(cpr == null) { 9810 //remove from mProvidersByClass 9811 if(DEBUG_ALL) Slog.v(TAG, name+" content provider not found in providers list"); 9812 return; 9813 } 9814 9815 //update content provider record entry info 9816 ComponentName comp = new ComponentName(cpr.info.packageName, cpr.info.name); 9817 ContentProviderRecord localCpr = mProviderMap.getProviderByClass(comp, userId); 9818 if (localCpr.hasExternalProcessHandles()) { 9819 if (localCpr.removeExternalProcessHandleLocked(token)) { 9820 updateOomAdjLocked(); 9821 } else { 9822 Slog.e(TAG, "Attmpt to remove content provider " + localCpr 9823 + " with no external reference for token: " 9824 + token + "."); 9825 } 9826 } else { 9827 Slog.e(TAG, "Attmpt to remove content provider: " + localCpr 9828 + " with no external references."); 9829 } 9830 } 9831 } 9832 9833 public final void publishContentProviders(IApplicationThread caller, 9834 List<ContentProviderHolder> providers) { 9835 if (providers == null) { 9836 return; 9837 } 9838 9839 enforceNotIsolatedCaller("publishContentProviders"); 9840 synchronized (this) { 9841 final ProcessRecord r = getRecordForAppLocked(caller); 9842 if (DEBUG_MU) Slog.v(TAG_MU, "ProcessRecord uid = " + r.uid); 9843 if (r == null) { 9844 throw new SecurityException( 9845 "Unable to find app for caller " + caller 9846 + " (pid=" + Binder.getCallingPid() 9847 + ") when publishing content providers"); 9848 } 9849 9850 final long origId = Binder.clearCallingIdentity(); 9851 9852 final int N = providers.size(); 9853 for (int i=0; i<N; i++) { 9854 ContentProviderHolder src = providers.get(i); 9855 if (src == null || src.info == null || src.provider == null) { 9856 continue; 9857 } 9858 ContentProviderRecord dst = r.pubProviders.get(src.info.name); 9859 if (DEBUG_MU) Slog.v(TAG_MU, "ContentProviderRecord uid = " + dst.uid); 9860 if (dst != null) { 9861 ComponentName comp = new ComponentName(dst.info.packageName, dst.info.name); 9862 mProviderMap.putProviderByClass(comp, dst); 9863 String names[] = dst.info.authority.split(";"); 9864 for (int j = 0; j < names.length; j++) { 9865 mProviderMap.putProviderByName(names[j], dst); 9866 } 9867 9868 int NL = mLaunchingProviders.size(); 9869 int j; 9870 for (j=0; j<NL; j++) { 9871 if (mLaunchingProviders.get(j) == dst) { 9872 mLaunchingProviders.remove(j); 9873 j--; 9874 NL--; 9875 } 9876 } 9877 synchronized (dst) { 9878 dst.provider = src.provider; 9879 dst.proc = r; 9880 dst.notifyAll(); 9881 } 9882 updateOomAdjLocked(r); 9883 maybeUpdateProviderUsageStatsLocked(r, src.info.packageName, 9884 src.info.authority); 9885 } 9886 } 9887 9888 Binder.restoreCallingIdentity(origId); 9889 } 9890 } 9891 9892 public boolean refContentProvider(IBinder connection, int stable, int unstable) { 9893 ContentProviderConnection conn; 9894 try { 9895 conn = (ContentProviderConnection)connection; 9896 } catch (ClassCastException e) { 9897 String msg ="refContentProvider: " + connection 9898 + " not a ContentProviderConnection"; 9899 Slog.w(TAG, msg); 9900 throw new IllegalArgumentException(msg); 9901 } 9902 if (conn == null) { 9903 throw new NullPointerException("connection is null"); 9904 } 9905 9906 synchronized (this) { 9907 if (stable > 0) { 9908 conn.numStableIncs += stable; 9909 } 9910 stable = conn.stableCount + stable; 9911 if (stable < 0) { 9912 throw new IllegalStateException("stableCount < 0: " + stable); 9913 } 9914 9915 if (unstable > 0) { 9916 conn.numUnstableIncs += unstable; 9917 } 9918 unstable = conn.unstableCount + unstable; 9919 if (unstable < 0) { 9920 throw new IllegalStateException("unstableCount < 0: " + unstable); 9921 } 9922 9923 if ((stable+unstable) <= 0) { 9924 throw new IllegalStateException("ref counts can't go to zero here: stable=" 9925 + stable + " unstable=" + unstable); 9926 } 9927 conn.stableCount = stable; 9928 conn.unstableCount = unstable; 9929 return !conn.dead; 9930 } 9931 } 9932 9933 public void unstableProviderDied(IBinder connection) { 9934 ContentProviderConnection conn; 9935 try { 9936 conn = (ContentProviderConnection)connection; 9937 } catch (ClassCastException e) { 9938 String msg ="refContentProvider: " + connection 9939 + " not a ContentProviderConnection"; 9940 Slog.w(TAG, msg); 9941 throw new IllegalArgumentException(msg); 9942 } 9943 if (conn == null) { 9944 throw new NullPointerException("connection is null"); 9945 } 9946 9947 // Safely retrieve the content provider associated with the connection. 9948 IContentProvider provider; 9949 synchronized (this) { 9950 provider = conn.provider.provider; 9951 } 9952 9953 if (provider == null) { 9954 // Um, yeah, we're way ahead of you. 9955 return; 9956 } 9957 9958 // Make sure the caller is being honest with us. 9959 if (provider.asBinder().pingBinder()) { 9960 // Er, no, still looks good to us. 9961 synchronized (this) { 9962 Slog.w(TAG, "unstableProviderDied: caller " + Binder.getCallingUid() 9963 + " says " + conn + " died, but we don't agree"); 9964 return; 9965 } 9966 } 9967 9968 // Well look at that! It's dead! 9969 synchronized (this) { 9970 if (conn.provider.provider != provider) { 9971 // But something changed... good enough. 9972 return; 9973 } 9974 9975 ProcessRecord proc = conn.provider.proc; 9976 if (proc == null || proc.thread == null) { 9977 // Seems like the process is already cleaned up. 9978 return; 9979 } 9980 9981 // As far as we're concerned, this is just like receiving a 9982 // death notification... just a bit prematurely. 9983 Slog.i(TAG, "Process " + proc.processName + " (pid " + proc.pid 9984 + ") early provider death"); 9985 final long ident = Binder.clearCallingIdentity(); 9986 try { 9987 appDiedLocked(proc); 9988 } finally { 9989 Binder.restoreCallingIdentity(ident); 9990 } 9991 } 9992 } 9993 9994 @Override 9995 public void appNotRespondingViaProvider(IBinder connection) { 9996 enforceCallingPermission( 9997 android.Manifest.permission.REMOVE_TASKS, "appNotRespondingViaProvider()"); 9998 9999 final ContentProviderConnection conn = (ContentProviderConnection) connection; 10000 if (conn == null) { 10001 Slog.w(TAG, "ContentProviderConnection is null"); 10002 return; 10003 } 10004 10005 final ProcessRecord host = conn.provider.proc; 10006 if (host == null) { 10007 Slog.w(TAG, "Failed to find hosting ProcessRecord"); 10008 return; 10009 } 10010 10011 final long token = Binder.clearCallingIdentity(); 10012 try { 10013 appNotResponding(host, null, null, false, "ContentProvider not responding"); 10014 } finally { 10015 Binder.restoreCallingIdentity(token); 10016 } 10017 } 10018 10019 public final void installSystemProviders() { 10020 List<ProviderInfo> providers; 10021 synchronized (this) { 10022 ProcessRecord app = mProcessNames.get("system", Process.SYSTEM_UID); 10023 providers = generateApplicationProvidersLocked(app); 10024 if (providers != null) { 10025 for (int i=providers.size()-1; i>=0; i--) { 10026 ProviderInfo pi = (ProviderInfo)providers.get(i); 10027 if ((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) { 10028 Slog.w(TAG, "Not installing system proc provider " + pi.name 10029 + ": not system .apk"); 10030 providers.remove(i); 10031 } 10032 } 10033 } 10034 } 10035 if (providers != null) { 10036 mSystemThread.installSystemProviders(providers); 10037 } 10038 10039 mCoreSettingsObserver = new CoreSettingsObserver(this); 10040 10041 //mUsageStatsService.monitorPackages(); 10042 } 10043 10044 /** 10045 * Allows apps to retrieve the MIME type of a URI. 10046 * If an app is in the same user as the ContentProvider, or if it is allowed to interact across 10047 * users, then it does not need permission to access the ContentProvider. 10048 * Either, it needs cross-user uri grants. 10049 * 10050 * CTS tests for this functionality can be run with "runtest cts-appsecurity". 10051 * 10052 * Test cases are at cts/tests/appsecurity-tests/test-apps/UsePermissionDiffCert/ 10053 * src/com/android/cts/usespermissiondiffcertapp/AccessPermissionWithDiffSigTest.java 10054 */ 10055 public String getProviderMimeType(Uri uri, int userId) { 10056 enforceNotIsolatedCaller("getProviderMimeType"); 10057 final String name = uri.getAuthority(); 10058 int callingUid = Binder.getCallingUid(); 10059 int callingPid = Binder.getCallingPid(); 10060 long ident = 0; 10061 boolean clearedIdentity = false; 10062 userId = unsafeConvertIncomingUser(userId); 10063 if (canClearIdentity(callingPid, callingUid, userId)) { 10064 clearedIdentity = true; 10065 ident = Binder.clearCallingIdentity(); 10066 } 10067 ContentProviderHolder holder = null; 10068 try { 10069 holder = getContentProviderExternalUnchecked(name, null, userId); 10070 if (holder != null) { 10071 return holder.provider.getType(uri); 10072 } 10073 } catch (RemoteException e) { 10074 Log.w(TAG, "Content provider dead retrieving " + uri, e); 10075 return null; 10076 } finally { 10077 // We need to clear the identity to call removeContentProviderExternalUnchecked 10078 if (!clearedIdentity) { 10079 ident = Binder.clearCallingIdentity(); 10080 } 10081 try { 10082 if (holder != null) { 10083 removeContentProviderExternalUnchecked(name, null, userId); 10084 } 10085 } finally { 10086 Binder.restoreCallingIdentity(ident); 10087 } 10088 } 10089 10090 return null; 10091 } 10092 10093 private boolean canClearIdentity(int callingPid, int callingUid, int userId) { 10094 if (UserHandle.getUserId(callingUid) == userId) { 10095 return true; 10096 } 10097 if (checkComponentPermission(INTERACT_ACROSS_USERS, callingPid, 10098 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED 10099 || checkComponentPermission(INTERACT_ACROSS_USERS_FULL, callingPid, 10100 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED) { 10101 return true; 10102 } 10103 return false; 10104 } 10105 10106 // ========================================================= 10107 // GLOBAL MANAGEMENT 10108 // ========================================================= 10109 10110 final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess, 10111 boolean isolated, int isolatedUid) { 10112 String proc = customProcess != null ? customProcess : info.processName; 10113 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 10114 final int userId = UserHandle.getUserId(info.uid); 10115 int uid = info.uid; 10116 if (isolated) { 10117 if (isolatedUid == 0) { 10118 int stepsLeft = Process.LAST_ISOLATED_UID - Process.FIRST_ISOLATED_UID + 1; 10119 while (true) { 10120 if (mNextIsolatedProcessUid < Process.FIRST_ISOLATED_UID 10121 || mNextIsolatedProcessUid > Process.LAST_ISOLATED_UID) { 10122 mNextIsolatedProcessUid = Process.FIRST_ISOLATED_UID; 10123 } 10124 uid = UserHandle.getUid(userId, mNextIsolatedProcessUid); 10125 mNextIsolatedProcessUid++; 10126 if (mIsolatedProcesses.indexOfKey(uid) < 0) { 10127 // No process for this uid, use it. 10128 break; 10129 } 10130 stepsLeft--; 10131 if (stepsLeft <= 0) { 10132 return null; 10133 } 10134 } 10135 } else { 10136 // Special case for startIsolatedProcess (internal only), where 10137 // the uid of the isolated process is specified by the caller. 10138 uid = isolatedUid; 10139 } 10140 } 10141 final ProcessRecord r = new ProcessRecord(stats, info, proc, uid); 10142 if (!mBooted && !mBooting 10143 && userId == UserHandle.USER_OWNER 10144 && (info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) { 10145 r.persistent = true; 10146 } 10147 addProcessNameLocked(r); 10148 return r; 10149 } 10150 10151 final ProcessRecord addAppLocked(ApplicationInfo info, boolean isolated, 10152 String abiOverride) { 10153 ProcessRecord app; 10154 if (!isolated) { 10155 app = getProcessRecordLocked(info.processName, info.uid, true); 10156 } else { 10157 app = null; 10158 } 10159 10160 if (app == null) { 10161 app = newProcessRecordLocked(info, null, isolated, 0); 10162 updateLruProcessLocked(app, false, null); 10163 updateOomAdjLocked(); 10164 } 10165 10166 // This package really, really can not be stopped. 10167 try { 10168 AppGlobals.getPackageManager().setPackageStoppedState( 10169 info.packageName, false, UserHandle.getUserId(app.uid)); 10170 } catch (RemoteException e) { 10171 } catch (IllegalArgumentException e) { 10172 Slog.w(TAG, "Failed trying to unstop package " 10173 + info.packageName + ": " + e); 10174 } 10175 10176 if ((info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) { 10177 app.persistent = true; 10178 app.maxAdj = ProcessList.PERSISTENT_PROC_ADJ; 10179 } 10180 if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) { 10181 mPersistentStartingProcesses.add(app); 10182 startProcessLocked(app, "added application", app.processName, abiOverride, 10183 null /* entryPoint */, null /* entryPointArgs */); 10184 } 10185 10186 return app; 10187 } 10188 10189 public void unhandledBack() { 10190 enforceCallingPermission(android.Manifest.permission.FORCE_BACK, 10191 "unhandledBack()"); 10192 10193 synchronized(this) { 10194 final long origId = Binder.clearCallingIdentity(); 10195 try { 10196 getFocusedStack().unhandledBackLocked(); 10197 } finally { 10198 Binder.restoreCallingIdentity(origId); 10199 } 10200 } 10201 } 10202 10203 public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException { 10204 enforceNotIsolatedCaller("openContentUri"); 10205 final int userId = UserHandle.getCallingUserId(); 10206 String name = uri.getAuthority(); 10207 ContentProviderHolder cph = getContentProviderExternalUnchecked(name, null, userId); 10208 ParcelFileDescriptor pfd = null; 10209 if (cph != null) { 10210 // We record the binder invoker's uid in thread-local storage before 10211 // going to the content provider to open the file. Later, in the code 10212 // that handles all permissions checks, we look for this uid and use 10213 // that rather than the Activity Manager's own uid. The effect is that 10214 // we do the check against the caller's permissions even though it looks 10215 // to the content provider like the Activity Manager itself is making 10216 // the request. 10217 Binder token = new Binder(); 10218 sCallerIdentity.set(new Identity( 10219 token, Binder.getCallingPid(), Binder.getCallingUid())); 10220 try { 10221 pfd = cph.provider.openFile(null, uri, "r", null, token); 10222 } catch (FileNotFoundException e) { 10223 // do nothing; pfd will be returned null 10224 } finally { 10225 // Ensure that whatever happens, we clean up the identity state 10226 sCallerIdentity.remove(); 10227 // Ensure we're done with the provider. 10228 removeContentProviderExternalUnchecked(name, null, userId); 10229 } 10230 } else { 10231 Slog.d(TAG, "Failed to get provider for authority '" + name + "'"); 10232 } 10233 return pfd; 10234 } 10235 10236 // Actually is sleeping or shutting down or whatever else in the future 10237 // is an inactive state. 10238 public boolean isSleepingOrShuttingDown() { 10239 return isSleeping() || mShuttingDown; 10240 } 10241 10242 public boolean isSleeping() { 10243 return mSleeping; 10244 } 10245 10246 void onWakefulnessChanged(int wakefulness) { 10247 synchronized(this) { 10248 mWakefulness = wakefulness; 10249 updateSleepIfNeededLocked(); 10250 } 10251 } 10252 10253 void finishRunningVoiceLocked() { 10254 if (mRunningVoice != null) { 10255 mRunningVoice = null; 10256 mVoiceWakeLock.release(); 10257 updateSleepIfNeededLocked(); 10258 } 10259 } 10260 10261 void startTimeTrackingFocusedActivityLocked() { 10262 if (!mSleeping && mCurAppTimeTracker != null && mFocusedActivity != null) { 10263 mCurAppTimeTracker.start(mFocusedActivity.packageName); 10264 } 10265 } 10266 10267 void updateSleepIfNeededLocked() { 10268 if (mSleeping && !shouldSleepLocked()) { 10269 mSleeping = false; 10270 startTimeTrackingFocusedActivityLocked(); 10271 mTopProcessState = ActivityManager.PROCESS_STATE_TOP; 10272 mStackSupervisor.comeOutOfSleepIfNeededLocked(); 10273 updateOomAdjLocked(); 10274 } else if (!mSleeping && shouldSleepLocked()) { 10275 mSleeping = true; 10276 if (mCurAppTimeTracker != null) { 10277 mCurAppTimeTracker.stop(); 10278 } 10279 mTopProcessState = ActivityManager.PROCESS_STATE_TOP_SLEEPING; 10280 mStackSupervisor.goingToSleepLocked(); 10281 updateOomAdjLocked(); 10282 10283 // Initialize the wake times of all processes. 10284 checkExcessivePowerUsageLocked(false); 10285 mHandler.removeMessages(CHECK_EXCESSIVE_WAKE_LOCKS_MSG); 10286 Message nmsg = mHandler.obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG); 10287 mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY); 10288 } 10289 } 10290 10291 private boolean shouldSleepLocked() { 10292 // Resume applications while running a voice interactor. 10293 if (mRunningVoice != null) { 10294 return false; 10295 } 10296 10297 // TODO: Transform the lock screen state into a sleep token instead. 10298 switch (mWakefulness) { 10299 case PowerManagerInternal.WAKEFULNESS_AWAKE: 10300 case PowerManagerInternal.WAKEFULNESS_DREAMING: 10301 case PowerManagerInternal.WAKEFULNESS_DOZING: 10302 // Pause applications whenever the lock screen is shown or any sleep 10303 // tokens have been acquired. 10304 return (mLockScreenShown != LOCK_SCREEN_HIDDEN || !mSleepTokens.isEmpty()); 10305 case PowerManagerInternal.WAKEFULNESS_ASLEEP: 10306 default: 10307 // If we're asleep then pause applications unconditionally. 10308 return true; 10309 } 10310 } 10311 10312 /** Pokes the task persister. */ 10313 void notifyTaskPersisterLocked(TaskRecord task, boolean flush) { 10314 if (task != null && task.stack != null && task.stack.isHomeStack()) { 10315 // Never persist the home stack. 10316 return; 10317 } 10318 mTaskPersister.wakeup(task, flush); 10319 } 10320 10321 /** Notifies all listeners when the task stack has changed. */ 10322 void notifyTaskStackChangedLocked() { 10323 mHandler.removeMessages(NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG); 10324 Message nmsg = mHandler.obtainMessage(NOTIFY_TASK_STACK_CHANGE_LISTENERS_MSG); 10325 mHandler.sendMessageDelayed(nmsg, NOTIFY_TASK_STACK_CHANGE_LISTENERS_DELAY); 10326 } 10327 10328 @Override 10329 public void notifyCleartextNetwork(int uid, byte[] firstPacket) { 10330 mHandler.obtainMessage(NOTIFY_CLEARTEXT_NETWORK_MSG, uid, 0, firstPacket).sendToTarget(); 10331 } 10332 10333 @Override 10334 public boolean shutdown(int timeout) { 10335 if (checkCallingPermission(android.Manifest.permission.SHUTDOWN) 10336 != PackageManager.PERMISSION_GRANTED) { 10337 throw new SecurityException("Requires permission " 10338 + android.Manifest.permission.SHUTDOWN); 10339 } 10340 10341 boolean timedout = false; 10342 10343 synchronized(this) { 10344 mShuttingDown = true; 10345 updateEventDispatchingLocked(); 10346 timedout = mStackSupervisor.shutdownLocked(timeout); 10347 } 10348 10349 mAppOpsService.shutdown(); 10350 if (mUsageStatsService != null) { 10351 mUsageStatsService.prepareShutdown(); 10352 } 10353 mBatteryStatsService.shutdown(); 10354 synchronized (this) { 10355 mProcessStats.shutdownLocked(); 10356 notifyTaskPersisterLocked(null, true); 10357 } 10358 10359 return timedout; 10360 } 10361 10362 public final void activitySlept(IBinder token) { 10363 if (DEBUG_ALL) Slog.v(TAG, "Activity slept: token=" + token); 10364 10365 final long origId = Binder.clearCallingIdentity(); 10366 10367 synchronized (this) { 10368 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 10369 if (r != null) { 10370 mStackSupervisor.activitySleptLocked(r); 10371 } 10372 } 10373 10374 Binder.restoreCallingIdentity(origId); 10375 } 10376 10377 private String lockScreenShownToString() { 10378 switch (mLockScreenShown) { 10379 case LOCK_SCREEN_HIDDEN: return "LOCK_SCREEN_HIDDEN"; 10380 case LOCK_SCREEN_LEAVING: return "LOCK_SCREEN_LEAVING"; 10381 case LOCK_SCREEN_SHOWN: return "LOCK_SCREEN_SHOWN"; 10382 default: return "Unknown=" + mLockScreenShown; 10383 } 10384 } 10385 10386 void logLockScreen(String msg) { 10387 if (DEBUG_LOCKSCREEN) Slog.d(TAG_LOCKSCREEN, Debug.getCallers(2) + ":" + msg 10388 + " mLockScreenShown=" + lockScreenShownToString() + " mWakefulness=" 10389 + PowerManagerInternal.wakefulnessToString(mWakefulness) 10390 + " mSleeping=" + mSleeping); 10391 } 10392 10393 void startRunningVoiceLocked(IVoiceInteractionSession session, int targetUid) { 10394 mVoiceWakeLock.setWorkSource(new WorkSource(targetUid)); 10395 if (mRunningVoice == null || mRunningVoice.asBinder() != session.asBinder()) { 10396 boolean wasRunningVoice = mRunningVoice != null; 10397 mRunningVoice = session; 10398 if (!wasRunningVoice) { 10399 mVoiceWakeLock.acquire(); 10400 updateSleepIfNeededLocked(); 10401 } 10402 } 10403 } 10404 10405 private void updateEventDispatchingLocked() { 10406 mWindowManager.setEventDispatching(mBooted && !mShuttingDown); 10407 } 10408 10409 public void setLockScreenShown(boolean shown) { 10410 if (checkCallingPermission(android.Manifest.permission.DEVICE_POWER) 10411 != PackageManager.PERMISSION_GRANTED) { 10412 throw new SecurityException("Requires permission " 10413 + android.Manifest.permission.DEVICE_POWER); 10414 } 10415 10416 synchronized(this) { 10417 long ident = Binder.clearCallingIdentity(); 10418 try { 10419 if (DEBUG_LOCKSCREEN) logLockScreen(" shown=" + shown); 10420 mLockScreenShown = shown ? LOCK_SCREEN_SHOWN : LOCK_SCREEN_HIDDEN; 10421 updateSleepIfNeededLocked(); 10422 } finally { 10423 Binder.restoreCallingIdentity(ident); 10424 } 10425 } 10426 } 10427 10428 @Override 10429 public void stopAppSwitches() { 10430 if (checkCallingPermission(android.Manifest.permission.STOP_APP_SWITCHES) 10431 != PackageManager.PERMISSION_GRANTED) { 10432 throw new SecurityException("Requires permission " 10433 + android.Manifest.permission.STOP_APP_SWITCHES); 10434 } 10435 10436 synchronized(this) { 10437 mAppSwitchesAllowedTime = SystemClock.uptimeMillis() 10438 + APP_SWITCH_DELAY_TIME; 10439 mDidAppSwitch = false; 10440 mHandler.removeMessages(DO_PENDING_ACTIVITY_LAUNCHES_MSG); 10441 Message msg = mHandler.obtainMessage(DO_PENDING_ACTIVITY_LAUNCHES_MSG); 10442 mHandler.sendMessageDelayed(msg, APP_SWITCH_DELAY_TIME); 10443 } 10444 } 10445 10446 public void resumeAppSwitches() { 10447 if (checkCallingPermission(android.Manifest.permission.STOP_APP_SWITCHES) 10448 != PackageManager.PERMISSION_GRANTED) { 10449 throw new SecurityException("Requires permission " 10450 + android.Manifest.permission.STOP_APP_SWITCHES); 10451 } 10452 10453 synchronized(this) { 10454 // Note that we don't execute any pending app switches... we will 10455 // let those wait until either the timeout, or the next start 10456 // activity request. 10457 mAppSwitchesAllowedTime = 0; 10458 } 10459 } 10460 10461 boolean checkAppSwitchAllowedLocked(int sourcePid, int sourceUid, 10462 int callingPid, int callingUid, String name) { 10463 if (mAppSwitchesAllowedTime < SystemClock.uptimeMillis()) { 10464 return true; 10465 } 10466 10467 int perm = checkComponentPermission( 10468 android.Manifest.permission.STOP_APP_SWITCHES, sourcePid, 10469 sourceUid, -1, true); 10470 if (perm == PackageManager.PERMISSION_GRANTED) { 10471 return true; 10472 } 10473 10474 // If the actual IPC caller is different from the logical source, then 10475 // also see if they are allowed to control app switches. 10476 if (callingUid != -1 && callingUid != sourceUid) { 10477 perm = checkComponentPermission( 10478 android.Manifest.permission.STOP_APP_SWITCHES, callingPid, 10479 callingUid, -1, true); 10480 if (perm == PackageManager.PERMISSION_GRANTED) { 10481 return true; 10482 } 10483 } 10484 10485 Slog.w(TAG, name + " request from " + sourceUid + " stopped"); 10486 return false; 10487 } 10488 10489 public void setDebugApp(String packageName, boolean waitForDebugger, 10490 boolean persistent) { 10491 enforceCallingPermission(android.Manifest.permission.SET_DEBUG_APP, 10492 "setDebugApp()"); 10493 10494 long ident = Binder.clearCallingIdentity(); 10495 try { 10496 // Note that this is not really thread safe if there are multiple 10497 // callers into it at the same time, but that's not a situation we 10498 // care about. 10499 if (persistent) { 10500 final ContentResolver resolver = mContext.getContentResolver(); 10501 Settings.Global.putString( 10502 resolver, Settings.Global.DEBUG_APP, 10503 packageName); 10504 Settings.Global.putInt( 10505 resolver, Settings.Global.WAIT_FOR_DEBUGGER, 10506 waitForDebugger ? 1 : 0); 10507 } 10508 10509 synchronized (this) { 10510 if (!persistent) { 10511 mOrigDebugApp = mDebugApp; 10512 mOrigWaitForDebugger = mWaitForDebugger; 10513 } 10514 mDebugApp = packageName; 10515 mWaitForDebugger = waitForDebugger; 10516 mDebugTransient = !persistent; 10517 if (packageName != null) { 10518 forceStopPackageLocked(packageName, -1, false, false, true, true, 10519 false, UserHandle.USER_ALL, "set debug app"); 10520 } 10521 } 10522 } finally { 10523 Binder.restoreCallingIdentity(ident); 10524 } 10525 } 10526 10527 void setOpenGlTraceApp(ApplicationInfo app, String processName) { 10528 synchronized (this) { 10529 boolean isDebuggable = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 10530 if (!isDebuggable) { 10531 if ((app.flags & ApplicationInfo.FLAG_DEBUGGABLE) == 0) { 10532 throw new SecurityException("Process not debuggable: " + app.packageName); 10533 } 10534 } 10535 10536 mOpenGlTraceApp = processName; 10537 } 10538 } 10539 10540 void setTrackAllocationApp(ApplicationInfo app, String processName) { 10541 synchronized (this) { 10542 boolean isDebuggable = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 10543 if (!isDebuggable) { 10544 if ((app.flags & ApplicationInfo.FLAG_DEBUGGABLE) == 0) { 10545 throw new SecurityException("Process not debuggable: " + app.packageName); 10546 } 10547 } 10548 10549 mTrackAllocationApp = processName; 10550 } 10551 } 10552 10553 void setProfileApp(ApplicationInfo app, String processName, ProfilerInfo profilerInfo) { 10554 synchronized (this) { 10555 boolean isDebuggable = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 10556 if (!isDebuggable) { 10557 if ((app.flags & ApplicationInfo.FLAG_DEBUGGABLE) == 0) { 10558 throw new SecurityException("Process not debuggable: " + app.packageName); 10559 } 10560 } 10561 mProfileApp = processName; 10562 mProfileFile = profilerInfo.profileFile; 10563 if (mProfileFd != null) { 10564 try { 10565 mProfileFd.close(); 10566 } catch (IOException e) { 10567 } 10568 mProfileFd = null; 10569 } 10570 mProfileFd = profilerInfo.profileFd; 10571 mSamplingInterval = profilerInfo.samplingInterval; 10572 mAutoStopProfiler = profilerInfo.autoStopProfiler; 10573 mProfileType = 0; 10574 } 10575 } 10576 10577 @Override 10578 public void setAlwaysFinish(boolean enabled) { 10579 enforceCallingPermission(android.Manifest.permission.SET_ALWAYS_FINISH, 10580 "setAlwaysFinish()"); 10581 10582 Settings.Global.putInt( 10583 mContext.getContentResolver(), 10584 Settings.Global.ALWAYS_FINISH_ACTIVITIES, enabled ? 1 : 0); 10585 10586 synchronized (this) { 10587 mAlwaysFinishActivities = enabled; 10588 } 10589 } 10590 10591 @Override 10592 public void setActivityController(IActivityController controller) { 10593 enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER, 10594 "setActivityController()"); 10595 synchronized (this) { 10596 mController = controller; 10597 Watchdog.getInstance().setActivityController(controller); 10598 } 10599 } 10600 10601 @Override 10602 public void setUserIsMonkey(boolean userIsMonkey) { 10603 synchronized (this) { 10604 synchronized (mPidsSelfLocked) { 10605 final int callingPid = Binder.getCallingPid(); 10606 ProcessRecord precessRecord = mPidsSelfLocked.get(callingPid); 10607 if (precessRecord == null) { 10608 throw new SecurityException("Unknown process: " + callingPid); 10609 } 10610 if (precessRecord.instrumentationUiAutomationConnection == null) { 10611 throw new SecurityException("Only an instrumentation process " 10612 + "with a UiAutomation can call setUserIsMonkey"); 10613 } 10614 } 10615 mUserIsMonkey = userIsMonkey; 10616 } 10617 } 10618 10619 @Override 10620 public boolean isUserAMonkey() { 10621 synchronized (this) { 10622 // If there is a controller also implies the user is a monkey. 10623 return (mUserIsMonkey || mController != null); 10624 } 10625 } 10626 10627 public void requestBugReport() { 10628 enforceCallingPermission(android.Manifest.permission.DUMP, "requestBugReport"); 10629 SystemProperties.set("ctl.start", "bugreport"); 10630 } 10631 10632 public static long getInputDispatchingTimeoutLocked(ActivityRecord r) { 10633 return r != null ? getInputDispatchingTimeoutLocked(r.app) : KEY_DISPATCHING_TIMEOUT; 10634 } 10635 10636 public static long getInputDispatchingTimeoutLocked(ProcessRecord r) { 10637 if (r != null && (r.instrumentationClass != null || r.usingWrapper)) { 10638 return INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT; 10639 } 10640 return KEY_DISPATCHING_TIMEOUT; 10641 } 10642 10643 @Override 10644 public long inputDispatchingTimedOut(int pid, final boolean aboveSystem, String reason) { 10645 if (checkCallingPermission(android.Manifest.permission.FILTER_EVENTS) 10646 != PackageManager.PERMISSION_GRANTED) { 10647 throw new SecurityException("Requires permission " 10648 + android.Manifest.permission.FILTER_EVENTS); 10649 } 10650 ProcessRecord proc; 10651 long timeout; 10652 synchronized (this) { 10653 synchronized (mPidsSelfLocked) { 10654 proc = mPidsSelfLocked.get(pid); 10655 } 10656 timeout = getInputDispatchingTimeoutLocked(proc); 10657 } 10658 10659 if (!inputDispatchingTimedOut(proc, null, null, aboveSystem, reason)) { 10660 return -1; 10661 } 10662 10663 return timeout; 10664 } 10665 10666 /** 10667 * Handle input dispatching timeouts. 10668 * Returns whether input dispatching should be aborted or not. 10669 */ 10670 public boolean inputDispatchingTimedOut(final ProcessRecord proc, 10671 final ActivityRecord activity, final ActivityRecord parent, 10672 final boolean aboveSystem, String reason) { 10673 if (checkCallingPermission(android.Manifest.permission.FILTER_EVENTS) 10674 != PackageManager.PERMISSION_GRANTED) { 10675 throw new SecurityException("Requires permission " 10676 + android.Manifest.permission.FILTER_EVENTS); 10677 } 10678 10679 final String annotation; 10680 if (reason == null) { 10681 annotation = "Input dispatching timed out"; 10682 } else { 10683 annotation = "Input dispatching timed out (" + reason + ")"; 10684 } 10685 10686 if (proc != null) { 10687 synchronized (this) { 10688 if (proc.debugging) { 10689 return false; 10690 } 10691 10692 if (mDidDexOpt) { 10693 // Give more time since we were dexopting. 10694 mDidDexOpt = false; 10695 return false; 10696 } 10697 10698 if (proc.instrumentationClass != null) { 10699 Bundle info = new Bundle(); 10700 info.putString("shortMsg", "keyDispatchingTimedOut"); 10701 info.putString("longMsg", annotation); 10702 finishInstrumentationLocked(proc, Activity.RESULT_CANCELED, info); 10703 return true; 10704 } 10705 } 10706 mHandler.post(new Runnable() { 10707 @Override 10708 public void run() { 10709 appNotResponding(proc, activity, parent, aboveSystem, annotation); 10710 } 10711 }); 10712 } 10713 10714 return true; 10715 } 10716 10717 @Override 10718 public Bundle getAssistContextExtras(int requestType) { 10719 PendingAssistExtras pae = enqueueAssistContext(requestType, null, null, null, 10720 null, UserHandle.getCallingUserId(), null, PENDING_ASSIST_EXTRAS_TIMEOUT); 10721 if (pae == null) { 10722 return null; 10723 } 10724 synchronized (pae) { 10725 while (!pae.haveResult) { 10726 try { 10727 pae.wait(); 10728 } catch (InterruptedException e) { 10729 } 10730 } 10731 } 10732 synchronized (this) { 10733 buildAssistBundleLocked(pae, pae.result); 10734 mPendingAssistExtras.remove(pae); 10735 mUiHandler.removeCallbacks(pae); 10736 } 10737 return pae.extras; 10738 } 10739 10740 @Override 10741 public boolean isAssistDataAllowedOnCurrentActivity() { 10742 int userId = mCurrentUserId; 10743 synchronized (this) { 10744 ActivityRecord activity = getFocusedStack().topActivity(); 10745 if (activity == null) { 10746 return false; 10747 } 10748 userId = activity.userId; 10749 } 10750 DevicePolicyManager dpm = (DevicePolicyManager) mContext.getSystemService( 10751 Context.DEVICE_POLICY_SERVICE); 10752 return (dpm == null) || (!dpm.getScreenCaptureDisabled(null, userId)); 10753 } 10754 10755 @Override 10756 public boolean showAssistFromActivity(IBinder token, Bundle args) { 10757 long ident = Binder.clearCallingIdentity(); 10758 try { 10759 synchronized (this) { 10760 ActivityRecord caller = ActivityRecord.forTokenLocked(token); 10761 ActivityRecord top = getFocusedStack().topActivity(); 10762 if (top != caller) { 10763 Slog.w(TAG, "showAssistFromActivity failed: caller " + caller 10764 + " is not current top " + top); 10765 return false; 10766 } 10767 if (!top.nowVisible) { 10768 Slog.w(TAG, "showAssistFromActivity failed: caller " + caller 10769 + " is not visible"); 10770 return false; 10771 } 10772 } 10773 AssistUtils utils = new AssistUtils(mContext); 10774 return utils.showSessionForActiveService(args, 10775 VoiceInteractionSession.SHOW_SOURCE_APPLICATION, null, token); 10776 } finally { 10777 Binder.restoreCallingIdentity(ident); 10778 } 10779 } 10780 10781 @Override 10782 public boolean requestAssistContextExtras(int requestType, IResultReceiver receiver, 10783 IBinder activityToken) { 10784 return enqueueAssistContext(requestType, null, null, receiver, activityToken, 10785 UserHandle.getCallingUserId(), null, PENDING_ASSIST_EXTRAS_LONG_TIMEOUT) != null; 10786 } 10787 10788 private PendingAssistExtras enqueueAssistContext(int requestType, Intent intent, String hint, 10789 IResultReceiver receiver, IBinder activityToken, int userHandle, Bundle args, 10790 long timeout) { 10791 enforceCallingPermission(android.Manifest.permission.GET_TOP_ACTIVITY_INFO, 10792 "enqueueAssistContext()"); 10793 synchronized (this) { 10794 ActivityRecord activity = getFocusedStack().topActivity(); 10795 if (activity == null) { 10796 Slog.w(TAG, "getAssistContextExtras failed: no top activity"); 10797 return null; 10798 } 10799 if (activity.app == null || activity.app.thread == null) { 10800 Slog.w(TAG, "getAssistContextExtras failed: no process for " + activity); 10801 return null; 10802 } 10803 if (activityToken != null) { 10804 ActivityRecord caller = ActivityRecord.forTokenLocked(activityToken); 10805 if (activity != caller) { 10806 Slog.w(TAG, "enqueueAssistContext failed: caller " + caller 10807 + " is not current top " + activity); 10808 return null; 10809 } 10810 } 10811 PendingAssistExtras pae; 10812 Bundle extras = new Bundle(); 10813 if (args != null) { 10814 extras.putAll(args); 10815 } 10816 extras.putString(Intent.EXTRA_ASSIST_PACKAGE, activity.packageName); 10817 extras.putInt(Intent.EXTRA_ASSIST_UID, activity.app.uid); 10818 pae = new PendingAssistExtras(activity, extras, intent, hint, receiver, userHandle); 10819 try { 10820 activity.app.thread.requestAssistContextExtras(activity.appToken, pae, 10821 requestType); 10822 mPendingAssistExtras.add(pae); 10823 mUiHandler.postDelayed(pae, timeout); 10824 } catch (RemoteException e) { 10825 Slog.w(TAG, "getAssistContextExtras failed: crash calling " + activity); 10826 return null; 10827 } 10828 return pae; 10829 } 10830 } 10831 10832 void pendingAssistExtrasTimedOut(PendingAssistExtras pae) { 10833 IResultReceiver receiver; 10834 synchronized (this) { 10835 mPendingAssistExtras.remove(pae); 10836 receiver = pae.receiver; 10837 } 10838 if (receiver != null) { 10839 // Caller wants result sent back to them. 10840 try { 10841 pae.receiver.send(0, null); 10842 } catch (RemoteException e) { 10843 } 10844 } 10845 } 10846 10847 private void buildAssistBundleLocked(PendingAssistExtras pae, Bundle result) { 10848 if (result != null) { 10849 pae.extras.putBundle(Intent.EXTRA_ASSIST_CONTEXT, result); 10850 } 10851 if (pae.hint != null) { 10852 pae.extras.putBoolean(pae.hint, true); 10853 } 10854 } 10855 10856 public void reportAssistContextExtras(IBinder token, Bundle extras, AssistStructure structure, 10857 AssistContent content, Uri referrer) { 10858 PendingAssistExtras pae = (PendingAssistExtras)token; 10859 synchronized (pae) { 10860 pae.result = extras; 10861 pae.structure = structure; 10862 pae.content = content; 10863 if (referrer != null) { 10864 pae.extras.putParcelable(Intent.EXTRA_REFERRER, referrer); 10865 } 10866 pae.haveResult = true; 10867 pae.notifyAll(); 10868 if (pae.intent == null && pae.receiver == null) { 10869 // Caller is just waiting for the result. 10870 return; 10871 } 10872 } 10873 10874 // We are now ready to launch the assist activity. 10875 IResultReceiver sendReceiver = null; 10876 Bundle sendBundle = null; 10877 synchronized (this) { 10878 buildAssistBundleLocked(pae, extras); 10879 boolean exists = mPendingAssistExtras.remove(pae); 10880 mUiHandler.removeCallbacks(pae); 10881 if (!exists) { 10882 // Timed out. 10883 return; 10884 } 10885 if ((sendReceiver=pae.receiver) != null) { 10886 // Caller wants result sent back to them. 10887 sendBundle = new Bundle(); 10888 sendBundle.putBundle("data", pae.extras); 10889 sendBundle.putParcelable("structure", pae.structure); 10890 sendBundle.putParcelable("content", pae.content); 10891 } 10892 } 10893 if (sendReceiver != null) { 10894 try { 10895 sendReceiver.send(0, sendBundle); 10896 } catch (RemoteException e) { 10897 } 10898 return; 10899 } 10900 10901 long ident = Binder.clearCallingIdentity(); 10902 try { 10903 pae.intent.replaceExtras(pae.extras); 10904 pae.intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK 10905 | Intent.FLAG_ACTIVITY_SINGLE_TOP 10906 | Intent.FLAG_ACTIVITY_CLEAR_TOP); 10907 closeSystemDialogs("assist"); 10908 try { 10909 mContext.startActivityAsUser(pae.intent, new UserHandle(pae.userHandle)); 10910 } catch (ActivityNotFoundException e) { 10911 Slog.w(TAG, "No activity to handle assist action.", e); 10912 } 10913 } finally { 10914 Binder.restoreCallingIdentity(ident); 10915 } 10916 } 10917 10918 public boolean launchAssistIntent(Intent intent, int requestType, String hint, int userHandle, 10919 Bundle args) { 10920 return enqueueAssistContext(requestType, intent, hint, null, null, userHandle, args, 10921 PENDING_ASSIST_EXTRAS_TIMEOUT) != null; 10922 } 10923 10924 public void registerProcessObserver(IProcessObserver observer) { 10925 enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER, 10926 "registerProcessObserver()"); 10927 synchronized (this) { 10928 mProcessObservers.register(observer); 10929 } 10930 } 10931 10932 @Override 10933 public void unregisterProcessObserver(IProcessObserver observer) { 10934 synchronized (this) { 10935 mProcessObservers.unregister(observer); 10936 } 10937 } 10938 10939 public void registerUidObserver(IUidObserver observer) { 10940 enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER, 10941 "registerUidObserver()"); 10942 synchronized (this) { 10943 mUidObservers.register(observer); 10944 } 10945 } 10946 10947 @Override 10948 public void unregisterUidObserver(IUidObserver observer) { 10949 synchronized (this) { 10950 mUidObservers.unregister(observer); 10951 } 10952 } 10953 10954 @Override 10955 public boolean convertFromTranslucent(IBinder token) { 10956 final long origId = Binder.clearCallingIdentity(); 10957 try { 10958 synchronized (this) { 10959 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 10960 if (r == null) { 10961 return false; 10962 } 10963 final boolean translucentChanged = r.changeWindowTranslucency(true); 10964 if (translucentChanged) { 10965 r.task.stack.releaseBackgroundResources(r); 10966 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0); 10967 } 10968 mWindowManager.setAppFullscreen(token, true); 10969 return translucentChanged; 10970 } 10971 } finally { 10972 Binder.restoreCallingIdentity(origId); 10973 } 10974 } 10975 10976 @Override 10977 public boolean convertToTranslucent(IBinder token, ActivityOptions options) { 10978 final long origId = Binder.clearCallingIdentity(); 10979 try { 10980 synchronized (this) { 10981 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 10982 if (r == null) { 10983 return false; 10984 } 10985 int index = r.task.mActivities.lastIndexOf(r); 10986 if (index > 0) { 10987 ActivityRecord under = r.task.mActivities.get(index - 1); 10988 under.returningOptions = options; 10989 } 10990 final boolean translucentChanged = r.changeWindowTranslucency(false); 10991 if (translucentChanged) { 10992 r.task.stack.convertActivityToTranslucent(r); 10993 } 10994 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0); 10995 mWindowManager.setAppFullscreen(token, false); 10996 return translucentChanged; 10997 } 10998 } finally { 10999 Binder.restoreCallingIdentity(origId); 11000 } 11001 } 11002 11003 @Override 11004 public boolean requestVisibleBehind(IBinder token, boolean visible) { 11005 final long origId = Binder.clearCallingIdentity(); 11006 try { 11007 synchronized (this) { 11008 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 11009 if (r != null) { 11010 return mStackSupervisor.requestVisibleBehindLocked(r, visible); 11011 } 11012 } 11013 return false; 11014 } finally { 11015 Binder.restoreCallingIdentity(origId); 11016 } 11017 } 11018 11019 @Override 11020 public boolean isBackgroundVisibleBehind(IBinder token) { 11021 final long origId = Binder.clearCallingIdentity(); 11022 try { 11023 synchronized (this) { 11024 final ActivityStack stack = ActivityRecord.getStackLocked(token); 11025 final boolean visible = stack == null ? false : stack.hasVisibleBehindActivity(); 11026 if (DEBUG_VISIBLE_BEHIND) Slog.d(TAG_VISIBLE_BEHIND, 11027 "isBackgroundVisibleBehind: stack=" + stack + " visible=" + visible); 11028 return visible; 11029 } 11030 } finally { 11031 Binder.restoreCallingIdentity(origId); 11032 } 11033 } 11034 11035 @Override 11036 public ActivityOptions getActivityOptions(IBinder token) { 11037 final long origId = Binder.clearCallingIdentity(); 11038 try { 11039 synchronized (this) { 11040 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 11041 if (r != null) { 11042 final ActivityOptions activityOptions = r.pendingOptions; 11043 r.pendingOptions = null; 11044 return activityOptions; 11045 } 11046 return null; 11047 } 11048 } finally { 11049 Binder.restoreCallingIdentity(origId); 11050 } 11051 } 11052 11053 @Override 11054 public void setImmersive(IBinder token, boolean immersive) { 11055 synchronized(this) { 11056 final ActivityRecord r = ActivityRecord.isInStackLocked(token); 11057 if (r == null) { 11058 throw new IllegalArgumentException(); 11059 } 11060 r.immersive = immersive; 11061 11062 // update associated state if we're frontmost 11063 if (r == mFocusedActivity) { 11064 if (DEBUG_IMMERSIVE) Slog.d(TAG_IMMERSIVE, "Frontmost changed immersion: "+ r); 11065 applyUpdateLockStateLocked(r); 11066 } 11067 } 11068 } 11069 11070 @Override 11071 public boolean isImmersive(IBinder token) { 11072 synchronized (this) { 11073 ActivityRecord r = ActivityRecord.isInStackLocked(token); 11074 if (r == null) { 11075 throw new IllegalArgumentException(); 11076 } 11077 return r.immersive; 11078 } 11079 } 11080 11081 public boolean isTopActivityImmersive() { 11082 enforceNotIsolatedCaller("startActivity"); 11083 synchronized (this) { 11084 ActivityRecord r = getFocusedStack().topRunningActivityLocked(null); 11085 return (r != null) ? r.immersive : false; 11086 } 11087 } 11088 11089 @Override 11090 public boolean isTopOfTask(IBinder token) { 11091 synchronized (this) { 11092 ActivityRecord r = ActivityRecord.isInStackLocked(token); 11093 if (r == null) { 11094 throw new IllegalArgumentException(); 11095 } 11096 return r.task.getTopActivity() == r; 11097 } 11098 } 11099 11100 public final void enterSafeMode() { 11101 synchronized(this) { 11102 // It only makes sense to do this before the system is ready 11103 // and started launching other packages. 11104 if (!mSystemReady) { 11105 try { 11106 AppGlobals.getPackageManager().enterSafeMode(); 11107 } catch (RemoteException e) { 11108 } 11109 } 11110 11111 mSafeMode = true; 11112 } 11113 } 11114 11115 public final void showSafeModeOverlay() { 11116 View v = LayoutInflater.from(mContext).inflate( 11117 com.android.internal.R.layout.safe_mode, null); 11118 WindowManager.LayoutParams lp = new WindowManager.LayoutParams(); 11119 lp.type = WindowManager.LayoutParams.TYPE_SECURE_SYSTEM_OVERLAY; 11120 lp.width = WindowManager.LayoutParams.WRAP_CONTENT; 11121 lp.height = WindowManager.LayoutParams.WRAP_CONTENT; 11122 lp.gravity = Gravity.BOTTOM | Gravity.START; 11123 lp.format = v.getBackground().getOpacity(); 11124 lp.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE 11125 | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; 11126 lp.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS; 11127 ((WindowManager)mContext.getSystemService( 11128 Context.WINDOW_SERVICE)).addView(v, lp); 11129 } 11130 11131 public void noteWakeupAlarm(IIntentSender sender, int sourceUid, String sourcePkg, String tag) { 11132 if (!(sender instanceof PendingIntentRecord)) { 11133 return; 11134 } 11135 final PendingIntentRecord rec = (PendingIntentRecord)sender; 11136 final BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 11137 synchronized (stats) { 11138 if (mBatteryStatsService.isOnBattery()) { 11139 mBatteryStatsService.enforceCallingPermission(); 11140 int MY_UID = Binder.getCallingUid(); 11141 int uid = rec.uid == MY_UID ? Process.SYSTEM_UID : rec.uid; 11142 BatteryStatsImpl.Uid.Pkg pkg = 11143 stats.getPackageStatsLocked(sourceUid >= 0 ? sourceUid : uid, 11144 sourcePkg != null ? sourcePkg : rec.key.packageName); 11145 pkg.noteWakeupAlarmLocked(tag); 11146 } 11147 } 11148 } 11149 11150 public void noteAlarmStart(IIntentSender sender, int sourceUid, String tag) { 11151 if (!(sender instanceof PendingIntentRecord)) { 11152 return; 11153 } 11154 final PendingIntentRecord rec = (PendingIntentRecord)sender; 11155 final BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 11156 synchronized (stats) { 11157 mBatteryStatsService.enforceCallingPermission(); 11158 int MY_UID = Binder.getCallingUid(); 11159 int uid = rec.uid == MY_UID ? Process.SYSTEM_UID : rec.uid; 11160 mBatteryStatsService.noteAlarmStart(tag, sourceUid >= 0 ? sourceUid : uid); 11161 } 11162 } 11163 11164 public void noteAlarmFinish(IIntentSender sender, int sourceUid, String tag) { 11165 if (!(sender instanceof PendingIntentRecord)) { 11166 return; 11167 } 11168 final PendingIntentRecord rec = (PendingIntentRecord)sender; 11169 final BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 11170 synchronized (stats) { 11171 mBatteryStatsService.enforceCallingPermission(); 11172 int MY_UID = Binder.getCallingUid(); 11173 int uid = rec.uid == MY_UID ? Process.SYSTEM_UID : rec.uid; 11174 mBatteryStatsService.noteAlarmFinish(tag, sourceUid >= 0 ? sourceUid : uid); 11175 } 11176 } 11177 11178 public boolean killPids(int[] pids, String pReason, boolean secure) { 11179 if (Binder.getCallingUid() != Process.SYSTEM_UID) { 11180 throw new SecurityException("killPids only available to the system"); 11181 } 11182 String reason = (pReason == null) ? "Unknown" : pReason; 11183 // XXX Note: don't acquire main activity lock here, because the window 11184 // manager calls in with its locks held. 11185 11186 boolean killed = false; 11187 synchronized (mPidsSelfLocked) { 11188 int[] types = new int[pids.length]; 11189 int worstType = 0; 11190 for (int i=0; i<pids.length; i++) { 11191 ProcessRecord proc = mPidsSelfLocked.get(pids[i]); 11192 if (proc != null) { 11193 int type = proc.setAdj; 11194 types[i] = type; 11195 if (type > worstType) { 11196 worstType = type; 11197 } 11198 } 11199 } 11200 11201 // If the worst oom_adj is somewhere in the cached proc LRU range, 11202 // then constrain it so we will kill all cached procs. 11203 if (worstType < ProcessList.CACHED_APP_MAX_ADJ 11204 && worstType > ProcessList.CACHED_APP_MIN_ADJ) { 11205 worstType = ProcessList.CACHED_APP_MIN_ADJ; 11206 } 11207 11208 // If this is not a secure call, don't let it kill processes that 11209 // are important. 11210 if (!secure && worstType < ProcessList.SERVICE_ADJ) { 11211 worstType = ProcessList.SERVICE_ADJ; 11212 } 11213 11214 Slog.w(TAG, "Killing processes " + reason + " at adjustment " + worstType); 11215 for (int i=0; i<pids.length; i++) { 11216 ProcessRecord proc = mPidsSelfLocked.get(pids[i]); 11217 if (proc == null) { 11218 continue; 11219 } 11220 int adj = proc.setAdj; 11221 if (adj >= worstType && !proc.killedByAm) { 11222 proc.kill(reason, true); 11223 killed = true; 11224 } 11225 } 11226 } 11227 return killed; 11228 } 11229 11230 @Override 11231 public void killUid(int appId, int userId, String reason) { 11232 enforceCallingPermission(Manifest.permission.KILL_UID, "killUid"); 11233 synchronized (this) { 11234 final long identity = Binder.clearCallingIdentity(); 11235 try { 11236 killPackageProcessesLocked(null, appId, userId, 11237 ProcessList.PERSISTENT_PROC_ADJ, false, true, true, true, 11238 reason != null ? reason : "kill uid"); 11239 } finally { 11240 Binder.restoreCallingIdentity(identity); 11241 } 11242 } 11243 } 11244 11245 @Override 11246 public boolean killProcessesBelowForeground(String reason) { 11247 if (Binder.getCallingUid() != Process.SYSTEM_UID) { 11248 throw new SecurityException("killProcessesBelowForeground() only available to system"); 11249 } 11250 11251 return killProcessesBelowAdj(ProcessList.FOREGROUND_APP_ADJ, reason); 11252 } 11253 11254 private boolean killProcessesBelowAdj(int belowAdj, String reason) { 11255 if (Binder.getCallingUid() != Process.SYSTEM_UID) { 11256 throw new SecurityException("killProcessesBelowAdj() only available to system"); 11257 } 11258 11259 boolean killed = false; 11260 synchronized (mPidsSelfLocked) { 11261 final int size = mPidsSelfLocked.size(); 11262 for (int i = 0; i < size; i++) { 11263 final int pid = mPidsSelfLocked.keyAt(i); 11264 final ProcessRecord proc = mPidsSelfLocked.valueAt(i); 11265 if (proc == null) continue; 11266 11267 final int adj = proc.setAdj; 11268 if (adj > belowAdj && !proc.killedByAm) { 11269 proc.kill(reason, true); 11270 killed = true; 11271 } 11272 } 11273 } 11274 return killed; 11275 } 11276 11277 @Override 11278 public void hang(final IBinder who, boolean allowRestart) { 11279 if (checkCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) 11280 != PackageManager.PERMISSION_GRANTED) { 11281 throw new SecurityException("Requires permission " 11282 + android.Manifest.permission.SET_ACTIVITY_WATCHER); 11283 } 11284 11285 final IBinder.DeathRecipient death = new DeathRecipient() { 11286 @Override 11287 public void binderDied() { 11288 synchronized (this) { 11289 notifyAll(); 11290 } 11291 } 11292 }; 11293 11294 try { 11295 who.linkToDeath(death, 0); 11296 } catch (RemoteException e) { 11297 Slog.w(TAG, "hang: given caller IBinder is already dead."); 11298 return; 11299 } 11300 11301 synchronized (this) { 11302 Watchdog.getInstance().setAllowRestart(allowRestart); 11303 Slog.i(TAG, "Hanging system process at request of pid " + Binder.getCallingPid()); 11304 synchronized (death) { 11305 while (who.isBinderAlive()) { 11306 try { 11307 death.wait(); 11308 } catch (InterruptedException e) { 11309 } 11310 } 11311 } 11312 Watchdog.getInstance().setAllowRestart(true); 11313 } 11314 } 11315 11316 @Override 11317 public void restart() { 11318 if (checkCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) 11319 != PackageManager.PERMISSION_GRANTED) { 11320 throw new SecurityException("Requires permission " 11321 + android.Manifest.permission.SET_ACTIVITY_WATCHER); 11322 } 11323 11324 Log.i(TAG, "Sending shutdown broadcast..."); 11325 11326 BroadcastReceiver br = new BroadcastReceiver() { 11327 @Override public void onReceive(Context context, Intent intent) { 11328 // Now the broadcast is done, finish up the low-level shutdown. 11329 Log.i(TAG, "Shutting down activity manager..."); 11330 shutdown(10000); 11331 Log.i(TAG, "Shutdown complete, restarting!"); 11332 Process.killProcess(Process.myPid()); 11333 System.exit(10); 11334 } 11335 }; 11336 11337 // First send the high-level shut down broadcast. 11338 Intent intent = new Intent(Intent.ACTION_SHUTDOWN); 11339 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); 11340 intent.putExtra(Intent.EXTRA_SHUTDOWN_USERSPACE_ONLY, true); 11341 /* For now we are not doing a clean shutdown, because things seem to get unhappy. 11342 mContext.sendOrderedBroadcastAsUser(intent, 11343 UserHandle.ALL, null, br, mHandler, 0, null, null); 11344 */ 11345 br.onReceive(mContext, intent); 11346 } 11347 11348 private long getLowRamTimeSinceIdle(long now) { 11349 return mLowRamTimeSinceLastIdle + (mLowRamStartTime > 0 ? (now-mLowRamStartTime) : 0); 11350 } 11351 11352 @Override 11353 public void performIdleMaintenance() { 11354 if (checkCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) 11355 != PackageManager.PERMISSION_GRANTED) { 11356 throw new SecurityException("Requires permission " 11357 + android.Manifest.permission.SET_ACTIVITY_WATCHER); 11358 } 11359 11360 synchronized (this) { 11361 final long now = SystemClock.uptimeMillis(); 11362 final long timeSinceLastIdle = now - mLastIdleTime; 11363 final long lowRamSinceLastIdle = getLowRamTimeSinceIdle(now); 11364 mLastIdleTime = now; 11365 mLowRamTimeSinceLastIdle = 0; 11366 if (mLowRamStartTime != 0) { 11367 mLowRamStartTime = now; 11368 } 11369 11370 StringBuilder sb = new StringBuilder(128); 11371 sb.append("Idle maintenance over "); 11372 TimeUtils.formatDuration(timeSinceLastIdle, sb); 11373 sb.append(" low RAM for "); 11374 TimeUtils.formatDuration(lowRamSinceLastIdle, sb); 11375 Slog.i(TAG, sb.toString()); 11376 11377 // If at least 1/3 of our time since the last idle period has been spent 11378 // with RAM low, then we want to kill processes. 11379 boolean doKilling = lowRamSinceLastIdle > (timeSinceLastIdle/3); 11380 11381 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 11382 ProcessRecord proc = mLruProcesses.get(i); 11383 if (proc.notCachedSinceIdle) { 11384 if (proc.setProcState != ActivityManager.PROCESS_STATE_TOP_SLEEPING 11385 && proc.setProcState >= ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE 11386 && proc.setProcState <= ActivityManager.PROCESS_STATE_SERVICE) { 11387 if (doKilling && proc.initialIdlePss != 0 11388 && proc.lastPss > ((proc.initialIdlePss*3)/2)) { 11389 sb = new StringBuilder(128); 11390 sb.append("Kill"); 11391 sb.append(proc.processName); 11392 sb.append(" in idle maint: pss="); 11393 sb.append(proc.lastPss); 11394 sb.append(", initialPss="); 11395 sb.append(proc.initialIdlePss); 11396 sb.append(", period="); 11397 TimeUtils.formatDuration(timeSinceLastIdle, sb); 11398 sb.append(", lowRamPeriod="); 11399 TimeUtils.formatDuration(lowRamSinceLastIdle, sb); 11400 Slog.wtfQuiet(TAG, sb.toString()); 11401 proc.kill("idle maint (pss " + proc.lastPss 11402 + " from " + proc.initialIdlePss + ")", true); 11403 } 11404 } 11405 } else if (proc.setProcState < ActivityManager.PROCESS_STATE_HOME) { 11406 proc.notCachedSinceIdle = true; 11407 proc.initialIdlePss = 0; 11408 proc.nextPssTime = ProcessList.computeNextPssTime(proc.curProcState, true, 11409 mTestPssMode, isSleeping(), now); 11410 } 11411 } 11412 11413 mHandler.removeMessages(REQUEST_ALL_PSS_MSG); 11414 mHandler.sendEmptyMessageDelayed(REQUEST_ALL_PSS_MSG, 2*60*1000); 11415 } 11416 } 11417 11418 private void retrieveSettings() { 11419 final ContentResolver resolver = mContext.getContentResolver(); 11420 String debugApp = Settings.Global.getString( 11421 resolver, Settings.Global.DEBUG_APP); 11422 boolean waitForDebugger = Settings.Global.getInt( 11423 resolver, Settings.Global.WAIT_FOR_DEBUGGER, 0) != 0; 11424 boolean alwaysFinishActivities = Settings.Global.getInt( 11425 resolver, Settings.Global.ALWAYS_FINISH_ACTIVITIES, 0) != 0; 11426 boolean forceRtl = Settings.Global.getInt( 11427 resolver, Settings.Global.DEVELOPMENT_FORCE_RTL, 0) != 0; 11428 // Transfer any global setting for forcing RTL layout, into a System Property 11429 SystemProperties.set(Settings.Global.DEVELOPMENT_FORCE_RTL, forceRtl ? "1":"0"); 11430 11431 Configuration configuration = new Configuration(); 11432 Settings.System.getConfiguration(resolver, configuration); 11433 if (forceRtl) { 11434 // This will take care of setting the correct layout direction flags 11435 configuration.setLayoutDirection(configuration.locale); 11436 } 11437 11438 synchronized (this) { 11439 mDebugApp = mOrigDebugApp = debugApp; 11440 mWaitForDebugger = mOrigWaitForDebugger = waitForDebugger; 11441 mAlwaysFinishActivities = alwaysFinishActivities; 11442 // This happens before any activities are started, so we can 11443 // change mConfiguration in-place. 11444 updateConfigurationLocked(configuration, null, false, true); 11445 if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, 11446 "Initial config: " + mConfiguration); 11447 } 11448 } 11449 11450 /** Loads resources after the current configuration has been set. */ 11451 private void loadResourcesOnSystemReady() { 11452 final Resources res = mContext.getResources(); 11453 mHasRecents = res.getBoolean(com.android.internal.R.bool.config_hasRecents); 11454 mThumbnailWidth = res.getDimensionPixelSize(com.android.internal.R.dimen.thumbnail_width); 11455 mThumbnailHeight = res.getDimensionPixelSize(com.android.internal.R.dimen.thumbnail_height); 11456 } 11457 11458 public boolean testIsSystemReady() { 11459 // no need to synchronize(this) just to read & return the value 11460 return mSystemReady; 11461 } 11462 11463 private static File getCalledPreBootReceiversFile() { 11464 File dataDir = Environment.getDataDirectory(); 11465 File systemDir = new File(dataDir, "system"); 11466 File fname = new File(systemDir, CALLED_PRE_BOOTS_FILENAME); 11467 return fname; 11468 } 11469 11470 private static ArrayList<ComponentName> readLastDonePreBootReceivers() { 11471 ArrayList<ComponentName> lastDoneReceivers = new ArrayList<ComponentName>(); 11472 File file = getCalledPreBootReceiversFile(); 11473 FileInputStream fis = null; 11474 try { 11475 fis = new FileInputStream(file); 11476 DataInputStream dis = new DataInputStream(new BufferedInputStream(fis, 2048)); 11477 int fvers = dis.readInt(); 11478 if (fvers == LAST_PREBOOT_DELIVERED_FILE_VERSION) { 11479 String vers = dis.readUTF(); 11480 String codename = dis.readUTF(); 11481 String build = dis.readUTF(); 11482 if (android.os.Build.VERSION.RELEASE.equals(vers) 11483 && android.os.Build.VERSION.CODENAME.equals(codename) 11484 && android.os.Build.VERSION.INCREMENTAL.equals(build)) { 11485 int num = dis.readInt(); 11486 while (num > 0) { 11487 num--; 11488 String pkg = dis.readUTF(); 11489 String cls = dis.readUTF(); 11490 lastDoneReceivers.add(new ComponentName(pkg, cls)); 11491 } 11492 } 11493 } 11494 } catch (FileNotFoundException e) { 11495 } catch (IOException e) { 11496 Slog.w(TAG, "Failure reading last done pre-boot receivers", e); 11497 } finally { 11498 if (fis != null) { 11499 try { 11500 fis.close(); 11501 } catch (IOException e) { 11502 } 11503 } 11504 } 11505 return lastDoneReceivers; 11506 } 11507 11508 private static void writeLastDonePreBootReceivers(ArrayList<ComponentName> list) { 11509 File file = getCalledPreBootReceiversFile(); 11510 FileOutputStream fos = null; 11511 DataOutputStream dos = null; 11512 try { 11513 fos = new FileOutputStream(file); 11514 dos = new DataOutputStream(new BufferedOutputStream(fos, 2048)); 11515 dos.writeInt(LAST_PREBOOT_DELIVERED_FILE_VERSION); 11516 dos.writeUTF(android.os.Build.VERSION.RELEASE); 11517 dos.writeUTF(android.os.Build.VERSION.CODENAME); 11518 dos.writeUTF(android.os.Build.VERSION.INCREMENTAL); 11519 dos.writeInt(list.size()); 11520 for (int i=0; i<list.size(); i++) { 11521 dos.writeUTF(list.get(i).getPackageName()); 11522 dos.writeUTF(list.get(i).getClassName()); 11523 } 11524 } catch (IOException e) { 11525 Slog.w(TAG, "Failure writing last done pre-boot receivers", e); 11526 file.delete(); 11527 } finally { 11528 FileUtils.sync(fos); 11529 if (dos != null) { 11530 try { 11531 dos.close(); 11532 } catch (IOException e) { 11533 // TODO Auto-generated catch block 11534 e.printStackTrace(); 11535 } 11536 } 11537 } 11538 } 11539 11540 final class PreBootContinuation extends IIntentReceiver.Stub { 11541 final Intent intent; 11542 final Runnable onFinishCallback; 11543 final ArrayList<ComponentName> doneReceivers; 11544 final List<ResolveInfo> ris; 11545 final int[] users; 11546 int lastRi = -1; 11547 int curRi = 0; 11548 int curUser = 0; 11549 11550 PreBootContinuation(Intent _intent, Runnable _onFinishCallback, 11551 ArrayList<ComponentName> _doneReceivers, List<ResolveInfo> _ris, int[] _users) { 11552 intent = _intent; 11553 onFinishCallback = _onFinishCallback; 11554 doneReceivers = _doneReceivers; 11555 ris = _ris; 11556 users = _users; 11557 } 11558 11559 void go() { 11560 if (lastRi != curRi) { 11561 ActivityInfo ai = ris.get(curRi).activityInfo; 11562 ComponentName comp = new ComponentName(ai.packageName, ai.name); 11563 intent.setComponent(comp); 11564 doneReceivers.add(comp); 11565 lastRi = curRi; 11566 CharSequence label = ai.loadLabel(mContext.getPackageManager()); 11567 showBootMessage(mContext.getString(R.string.android_preparing_apk, label), false); 11568 } 11569 Slog.i(TAG, "Pre-boot of " + intent.getComponent().toShortString() 11570 + " for user " + users[curUser]); 11571 EventLogTags.writeAmPreBoot(users[curUser], intent.getComponent().getPackageName()); 11572 broadcastIntentLocked(null, null, intent, null, this, 11573 0, null, null, null, AppOpsManager.OP_NONE, 11574 null, true, false, MY_PID, Process.SYSTEM_UID, users[curUser]); 11575 } 11576 11577 public void performReceive(Intent intent, int resultCode, 11578 String data, Bundle extras, boolean ordered, 11579 boolean sticky, int sendingUser) { 11580 curUser++; 11581 if (curUser >= users.length) { 11582 curUser = 0; 11583 curRi++; 11584 if (curRi >= ris.size()) { 11585 // All done sending broadcasts! 11586 if (onFinishCallback != null) { 11587 // The raw IIntentReceiver interface is called 11588 // with the AM lock held, so redispatch to 11589 // execute our code without the lock. 11590 mHandler.post(onFinishCallback); 11591 } 11592 return; 11593 } 11594 } 11595 go(); 11596 } 11597 } 11598 11599 private boolean deliverPreBootCompleted(final Runnable onFinishCallback, 11600 ArrayList<ComponentName> doneReceivers, int userId) { 11601 Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED); 11602 List<ResolveInfo> ris = null; 11603 try { 11604 ris = AppGlobals.getPackageManager().queryIntentReceivers( 11605 intent, null, 0, userId); 11606 } catch (RemoteException e) { 11607 } 11608 if (ris == null) { 11609 return false; 11610 } 11611 for (int i=ris.size()-1; i>=0; i--) { 11612 if ((ris.get(i).activityInfo.applicationInfo.flags 11613 &ApplicationInfo.FLAG_SYSTEM) == 0) { 11614 ris.remove(i); 11615 } 11616 } 11617 intent.addFlags(Intent.FLAG_RECEIVER_BOOT_UPGRADE); 11618 11619 // For User 0, load the version number. When delivering to a new user, deliver 11620 // to all receivers. 11621 if (userId == UserHandle.USER_OWNER) { 11622 ArrayList<ComponentName> lastDoneReceivers = readLastDonePreBootReceivers(); 11623 for (int i=0; i<ris.size(); i++) { 11624 ActivityInfo ai = ris.get(i).activityInfo; 11625 ComponentName comp = new ComponentName(ai.packageName, ai.name); 11626 if (lastDoneReceivers.contains(comp)) { 11627 // We already did the pre boot receiver for this app with the current 11628 // platform version, so don't do it again... 11629 ris.remove(i); 11630 i--; 11631 // ...however, do keep it as one that has been done, so we don't 11632 // forget about it when rewriting the file of last done receivers. 11633 doneReceivers.add(comp); 11634 } 11635 } 11636 } 11637 11638 if (ris.size() <= 0) { 11639 return false; 11640 } 11641 11642 // If primary user, send broadcast to all available users, else just to userId 11643 final int[] users = userId == UserHandle.USER_OWNER ? getUsersLocked() 11644 : new int[] { userId }; 11645 if (users.length <= 0) { 11646 return false; 11647 } 11648 11649 PreBootContinuation cont = new PreBootContinuation(intent, onFinishCallback, doneReceivers, 11650 ris, users); 11651 cont.go(); 11652 return true; 11653 } 11654 11655 public void systemReady(final Runnable goingCallback) { 11656 synchronized(this) { 11657 if (mSystemReady) { 11658 // If we're done calling all the receivers, run the next "boot phase" passed in 11659 // by the SystemServer 11660 if (goingCallback != null) { 11661 goingCallback.run(); 11662 } 11663 return; 11664 } 11665 11666 mLocalDeviceIdleController 11667 = LocalServices.getService(DeviceIdleController.LocalService.class); 11668 11669 // Make sure we have the current profile info, since it is needed for 11670 // security checks. 11671 updateCurrentProfileIdsLocked(); 11672 11673 mRecentTasks.clear(); 11674 mRecentTasks.addAll(mTaskPersister.restoreTasksLocked()); 11675 mRecentTasks.cleanupLocked(UserHandle.USER_ALL); 11676 mTaskPersister.startPersisting(); 11677 11678 // Check to see if there are any update receivers to run. 11679 if (!mDidUpdate) { 11680 if (mWaitingUpdate) { 11681 return; 11682 } 11683 final ArrayList<ComponentName> doneReceivers = new ArrayList<ComponentName>(); 11684 mWaitingUpdate = deliverPreBootCompleted(new Runnable() { 11685 public void run() { 11686 synchronized (ActivityManagerService.this) { 11687 mDidUpdate = true; 11688 } 11689 showBootMessage(mContext.getText( 11690 R.string.android_upgrading_complete), 11691 false); 11692 writeLastDonePreBootReceivers(doneReceivers); 11693 systemReady(goingCallback); 11694 } 11695 }, doneReceivers, UserHandle.USER_OWNER); 11696 11697 if (mWaitingUpdate) { 11698 return; 11699 } 11700 mDidUpdate = true; 11701 } 11702 11703 mAppOpsService.systemReady(); 11704 mSystemReady = true; 11705 } 11706 11707 ArrayList<ProcessRecord> procsToKill = null; 11708 synchronized(mPidsSelfLocked) { 11709 for (int i=mPidsSelfLocked.size()-1; i>=0; i--) { 11710 ProcessRecord proc = mPidsSelfLocked.valueAt(i); 11711 if (!isAllowedWhileBooting(proc.info)){ 11712 if (procsToKill == null) { 11713 procsToKill = new ArrayList<ProcessRecord>(); 11714 } 11715 procsToKill.add(proc); 11716 } 11717 } 11718 } 11719 11720 synchronized(this) { 11721 if (procsToKill != null) { 11722 for (int i=procsToKill.size()-1; i>=0; i--) { 11723 ProcessRecord proc = procsToKill.get(i); 11724 Slog.i(TAG, "Removing system update proc: " + proc); 11725 removeProcessLocked(proc, true, false, "system update done"); 11726 } 11727 } 11728 11729 // Now that we have cleaned up any update processes, we 11730 // are ready to start launching real processes and know that 11731 // we won't trample on them any more. 11732 mProcessesReady = true; 11733 } 11734 11735 Slog.i(TAG, "System now ready"); 11736 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY, 11737 SystemClock.uptimeMillis()); 11738 11739 synchronized(this) { 11740 // Make sure we have no pre-ready processes sitting around. 11741 11742 if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) { 11743 ResolveInfo ri = mContext.getPackageManager() 11744 .resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST), 11745 STOCK_PM_FLAGS); 11746 CharSequence errorMsg = null; 11747 if (ri != null) { 11748 ActivityInfo ai = ri.activityInfo; 11749 ApplicationInfo app = ai.applicationInfo; 11750 if ((app.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { 11751 mTopAction = Intent.ACTION_FACTORY_TEST; 11752 mTopData = null; 11753 mTopComponent = new ComponentName(app.packageName, 11754 ai.name); 11755 } else { 11756 errorMsg = mContext.getResources().getText( 11757 com.android.internal.R.string.factorytest_not_system); 11758 } 11759 } else { 11760 errorMsg = mContext.getResources().getText( 11761 com.android.internal.R.string.factorytest_no_action); 11762 } 11763 if (errorMsg != null) { 11764 mTopAction = null; 11765 mTopData = null; 11766 mTopComponent = null; 11767 Message msg = Message.obtain(); 11768 msg.what = SHOW_FACTORY_ERROR_MSG; 11769 msg.getData().putCharSequence("msg", errorMsg); 11770 mUiHandler.sendMessage(msg); 11771 } 11772 } 11773 } 11774 11775 retrieveSettings(); 11776 loadResourcesOnSystemReady(); 11777 11778 synchronized (this) { 11779 readGrantedUriPermissionsLocked(); 11780 } 11781 11782 if (goingCallback != null) goingCallback.run(); 11783 11784 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START, 11785 Integer.toString(mCurrentUserId), mCurrentUserId); 11786 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START, 11787 Integer.toString(mCurrentUserId), mCurrentUserId); 11788 mSystemServiceManager.startUser(mCurrentUserId); 11789 11790 synchronized (this) { 11791 if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) { 11792 try { 11793 List apps = AppGlobals.getPackageManager(). 11794 getPersistentApplications(STOCK_PM_FLAGS); 11795 if (apps != null) { 11796 int N = apps.size(); 11797 int i; 11798 for (i=0; i<N; i++) { 11799 ApplicationInfo info 11800 = (ApplicationInfo)apps.get(i); 11801 if (info != null && 11802 !info.packageName.equals("android")) { 11803 addAppLocked(info, false, null /* ABI override */); 11804 } 11805 } 11806 } 11807 } catch (RemoteException ex) { 11808 // pm is in same process, this will never happen. 11809 } 11810 } 11811 11812 // Start up initial activity. 11813 mBooting = true; 11814 startHomeActivityLocked(mCurrentUserId, "systemReady"); 11815 11816 try { 11817 if (AppGlobals.getPackageManager().hasSystemUidErrors()) { 11818 Slog.e(TAG, "UIDs on the system are inconsistent, you need to wipe your" 11819 + " data partition or your device will be unstable."); 11820 mUiHandler.obtainMessage(SHOW_UID_ERROR_MSG).sendToTarget(); 11821 } 11822 } catch (RemoteException e) { 11823 } 11824 11825 if (!Build.isBuildConsistent()) { 11826 Slog.e(TAG, "Build fingerprint is not consistent, warning user"); 11827 mUiHandler.obtainMessage(SHOW_FINGERPRINT_ERROR_MSG).sendToTarget(); 11828 } 11829 11830 long ident = Binder.clearCallingIdentity(); 11831 try { 11832 Intent intent = new Intent(Intent.ACTION_USER_STARTED); 11833 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 11834 | Intent.FLAG_RECEIVER_FOREGROUND); 11835 intent.putExtra(Intent.EXTRA_USER_HANDLE, mCurrentUserId); 11836 broadcastIntentLocked(null, null, intent, 11837 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 11838 null, false, false, MY_PID, Process.SYSTEM_UID, mCurrentUserId); 11839 intent = new Intent(Intent.ACTION_USER_STARTING); 11840 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 11841 intent.putExtra(Intent.EXTRA_USER_HANDLE, mCurrentUserId); 11842 broadcastIntentLocked(null, null, intent, 11843 null, new IIntentReceiver.Stub() { 11844 @Override 11845 public void performReceive(Intent intent, int resultCode, String data, 11846 Bundle extras, boolean ordered, boolean sticky, int sendingUser) 11847 throws RemoteException { 11848 } 11849 }, 0, null, null, 11850 new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, 11851 null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 11852 } catch (Throwable t) { 11853 Slog.wtf(TAG, "Failed sending first user broadcasts", t); 11854 } finally { 11855 Binder.restoreCallingIdentity(ident); 11856 } 11857 mStackSupervisor.resumeTopActivitiesLocked(); 11858 sendUserSwitchBroadcastsLocked(-1, mCurrentUserId); 11859 } 11860 } 11861 11862 private boolean makeAppCrashingLocked(ProcessRecord app, 11863 String shortMsg, String longMsg, String stackTrace) { 11864 app.crashing = true; 11865 app.crashingReport = generateProcessError(app, 11866 ActivityManager.ProcessErrorStateInfo.CRASHED, null, shortMsg, longMsg, stackTrace); 11867 startAppProblemLocked(app); 11868 app.stopFreezingAllLocked(); 11869 return handleAppCrashLocked(app, "force-crash" /*reason*/, shortMsg, longMsg, stackTrace); 11870 } 11871 11872 private void makeAppNotRespondingLocked(ProcessRecord app, 11873 String activity, String shortMsg, String longMsg) { 11874 app.notResponding = true; 11875 app.notRespondingReport = generateProcessError(app, 11876 ActivityManager.ProcessErrorStateInfo.NOT_RESPONDING, 11877 activity, shortMsg, longMsg, null); 11878 startAppProblemLocked(app); 11879 app.stopFreezingAllLocked(); 11880 } 11881 11882 /** 11883 * Generate a process error record, suitable for attachment to a ProcessRecord. 11884 * 11885 * @param app The ProcessRecord in which the error occurred. 11886 * @param condition Crashing, Application Not Responding, etc. Values are defined in 11887 * ActivityManager.AppErrorStateInfo 11888 * @param activity The activity associated with the crash, if known. 11889 * @param shortMsg Short message describing the crash. 11890 * @param longMsg Long message describing the crash. 11891 * @param stackTrace Full crash stack trace, may be null. 11892 * 11893 * @return Returns a fully-formed AppErrorStateInfo record. 11894 */ 11895 private ActivityManager.ProcessErrorStateInfo generateProcessError(ProcessRecord app, 11896 int condition, String activity, String shortMsg, String longMsg, String stackTrace) { 11897 ActivityManager.ProcessErrorStateInfo report = new ActivityManager.ProcessErrorStateInfo(); 11898 11899 report.condition = condition; 11900 report.processName = app.processName; 11901 report.pid = app.pid; 11902 report.uid = app.info.uid; 11903 report.tag = activity; 11904 report.shortMsg = shortMsg; 11905 report.longMsg = longMsg; 11906 report.stackTrace = stackTrace; 11907 11908 return report; 11909 } 11910 11911 void killAppAtUsersRequest(ProcessRecord app, Dialog fromDialog) { 11912 synchronized (this) { 11913 app.crashing = false; 11914 app.crashingReport = null; 11915 app.notResponding = false; 11916 app.notRespondingReport = null; 11917 if (app.anrDialog == fromDialog) { 11918 app.anrDialog = null; 11919 } 11920 if (app.waitDialog == fromDialog) { 11921 app.waitDialog = null; 11922 } 11923 if (app.pid > 0 && app.pid != MY_PID) { 11924 handleAppCrashLocked(app, "user-terminated" /*reason*/, 11925 null /*shortMsg*/, null /*longMsg*/, null /*stackTrace*/); 11926 app.kill("user request after error", true); 11927 } 11928 } 11929 } 11930 11931 private boolean handleAppCrashLocked(ProcessRecord app, String reason, 11932 String shortMsg, String longMsg, String stackTrace) { 11933 long now = SystemClock.uptimeMillis(); 11934 11935 Long crashTime; 11936 if (!app.isolated) { 11937 crashTime = mProcessCrashTimes.get(app.info.processName, app.uid); 11938 } else { 11939 crashTime = null; 11940 } 11941 if (crashTime != null && now < crashTime+ProcessList.MIN_CRASH_INTERVAL) { 11942 // This process loses! 11943 Slog.w(TAG, "Process " + app.info.processName 11944 + " has crashed too many times: killing!"); 11945 EventLog.writeEvent(EventLogTags.AM_PROCESS_CRASHED_TOO_MUCH, 11946 app.userId, app.info.processName, app.uid); 11947 mStackSupervisor.handleAppCrashLocked(app); 11948 if (!app.persistent) { 11949 // We don't want to start this process again until the user 11950 // explicitly does so... but for persistent process, we really 11951 // need to keep it running. If a persistent process is actually 11952 // repeatedly crashing, then badness for everyone. 11953 EventLog.writeEvent(EventLogTags.AM_PROC_BAD, app.userId, app.uid, 11954 app.info.processName); 11955 if (!app.isolated) { 11956 // XXX We don't have a way to mark isolated processes 11957 // as bad, since they don't have a peristent identity. 11958 mBadProcesses.put(app.info.processName, app.uid, 11959 new BadProcessInfo(now, shortMsg, longMsg, stackTrace)); 11960 mProcessCrashTimes.remove(app.info.processName, app.uid); 11961 } 11962 app.bad = true; 11963 app.removed = true; 11964 // Don't let services in this process be restarted and potentially 11965 // annoy the user repeatedly. Unless it is persistent, since those 11966 // processes run critical code. 11967 removeProcessLocked(app, false, false, "crash"); 11968 mStackSupervisor.resumeTopActivitiesLocked(); 11969 return false; 11970 } 11971 mStackSupervisor.resumeTopActivitiesLocked(); 11972 } else { 11973 mStackSupervisor.finishTopRunningActivityLocked(app, reason); 11974 } 11975 11976 // Bump up the crash count of any services currently running in the proc. 11977 for (int i=app.services.size()-1; i>=0; i--) { 11978 // Any services running in the application need to be placed 11979 // back in the pending list. 11980 ServiceRecord sr = app.services.valueAt(i); 11981 sr.crashCount++; 11982 } 11983 11984 // If the crashing process is what we consider to be the "home process" and it has been 11985 // replaced by a third-party app, clear the package preferred activities from packages 11986 // with a home activity running in the process to prevent a repeatedly crashing app 11987 // from blocking the user to manually clear the list. 11988 final ArrayList<ActivityRecord> activities = app.activities; 11989 if (app == mHomeProcess && activities.size() > 0 11990 && (mHomeProcess.info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) { 11991 for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) { 11992 final ActivityRecord r = activities.get(activityNdx); 11993 if (r.isHomeActivity()) { 11994 Log.i(TAG, "Clearing package preferred activities from " + r.packageName); 11995 try { 11996 ActivityThread.getPackageManager() 11997 .clearPackagePreferredActivities(r.packageName); 11998 } catch (RemoteException c) { 11999 // pm is in same process, this will never happen. 12000 } 12001 } 12002 } 12003 } 12004 12005 if (!app.isolated) { 12006 // XXX Can't keep track of crash times for isolated processes, 12007 // because they don't have a perisistent identity. 12008 mProcessCrashTimes.put(app.info.processName, app.uid, now); 12009 } 12010 12011 if (app.crashHandler != null) mHandler.post(app.crashHandler); 12012 return true; 12013 } 12014 12015 void startAppProblemLocked(ProcessRecord app) { 12016 // If this app is not running under the current user, then we 12017 // can't give it a report button because that would require 12018 // launching the report UI under a different user. 12019 app.errorReportReceiver = null; 12020 12021 for (int userId : mCurrentProfileIds) { 12022 if (app.userId == userId) { 12023 app.errorReportReceiver = ApplicationErrorReport.getErrorReportReceiver( 12024 mContext, app.info.packageName, app.info.flags); 12025 } 12026 } 12027 skipCurrentReceiverLocked(app); 12028 } 12029 12030 void skipCurrentReceiverLocked(ProcessRecord app) { 12031 for (BroadcastQueue queue : mBroadcastQueues) { 12032 queue.skipCurrentReceiverLocked(app); 12033 } 12034 } 12035 12036 /** 12037 * Used by {@link com.android.internal.os.RuntimeInit} to report when an application crashes. 12038 * The application process will exit immediately after this call returns. 12039 * @param app object of the crashing app, null for the system server 12040 * @param crashInfo describing the exception 12041 */ 12042 public void handleApplicationCrash(IBinder app, ApplicationErrorReport.CrashInfo crashInfo) { 12043 ProcessRecord r = findAppProcess(app, "Crash"); 12044 final String processName = app == null ? "system_server" 12045 : (r == null ? "unknown" : r.processName); 12046 12047 handleApplicationCrashInner("crash", r, processName, crashInfo); 12048 } 12049 12050 /* Native crash reporting uses this inner version because it needs to be somewhat 12051 * decoupled from the AM-managed cleanup lifecycle 12052 */ 12053 void handleApplicationCrashInner(String eventType, ProcessRecord r, String processName, 12054 ApplicationErrorReport.CrashInfo crashInfo) { 12055 EventLog.writeEvent(EventLogTags.AM_CRASH, Binder.getCallingPid(), 12056 UserHandle.getUserId(Binder.getCallingUid()), processName, 12057 r == null ? -1 : r.info.flags, 12058 crashInfo.exceptionClassName, 12059 crashInfo.exceptionMessage, 12060 crashInfo.throwFileName, 12061 crashInfo.throwLineNumber); 12062 12063 addErrorToDropBox(eventType, r, processName, null, null, null, null, null, crashInfo); 12064 12065 crashApplication(r, crashInfo); 12066 } 12067 12068 public void handleApplicationStrictModeViolation( 12069 IBinder app, 12070 int violationMask, 12071 StrictMode.ViolationInfo info) { 12072 ProcessRecord r = findAppProcess(app, "StrictMode"); 12073 if (r == null) { 12074 return; 12075 } 12076 12077 if ((violationMask & StrictMode.PENALTY_DROPBOX) != 0) { 12078 Integer stackFingerprint = info.hashCode(); 12079 boolean logIt = true; 12080 synchronized (mAlreadyLoggedViolatedStacks) { 12081 if (mAlreadyLoggedViolatedStacks.contains(stackFingerprint)) { 12082 logIt = false; 12083 // TODO: sub-sample into EventLog for these, with 12084 // the info.durationMillis? Then we'd get 12085 // the relative pain numbers, without logging all 12086 // the stack traces repeatedly. We'd want to do 12087 // likewise in the client code, which also does 12088 // dup suppression, before the Binder call. 12089 } else { 12090 if (mAlreadyLoggedViolatedStacks.size() >= MAX_DUP_SUPPRESSED_STACKS) { 12091 mAlreadyLoggedViolatedStacks.clear(); 12092 } 12093 mAlreadyLoggedViolatedStacks.add(stackFingerprint); 12094 } 12095 } 12096 if (logIt) { 12097 logStrictModeViolationToDropBox(r, info); 12098 } 12099 } 12100 12101 if ((violationMask & StrictMode.PENALTY_DIALOG) != 0) { 12102 AppErrorResult result = new AppErrorResult(); 12103 synchronized (this) { 12104 final long origId = Binder.clearCallingIdentity(); 12105 12106 Message msg = Message.obtain(); 12107 msg.what = SHOW_STRICT_MODE_VIOLATION_MSG; 12108 HashMap<String, Object> data = new HashMap<String, Object>(); 12109 data.put("result", result); 12110 data.put("app", r); 12111 data.put("violationMask", violationMask); 12112 data.put("info", info); 12113 msg.obj = data; 12114 mUiHandler.sendMessage(msg); 12115 12116 Binder.restoreCallingIdentity(origId); 12117 } 12118 int res = result.get(); 12119 Slog.w(TAG, "handleApplicationStrictModeViolation; res=" + res); 12120 } 12121 } 12122 12123 // Depending on the policy in effect, there could be a bunch of 12124 // these in quick succession so we try to batch these together to 12125 // minimize disk writes, number of dropbox entries, and maximize 12126 // compression, by having more fewer, larger records. 12127 private void logStrictModeViolationToDropBox( 12128 ProcessRecord process, 12129 StrictMode.ViolationInfo info) { 12130 if (info == null) { 12131 return; 12132 } 12133 final boolean isSystemApp = process == null || 12134 (process.info.flags & (ApplicationInfo.FLAG_SYSTEM | 12135 ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)) != 0; 12136 final String processName = process == null ? "unknown" : process.processName; 12137 final String dropboxTag = isSystemApp ? "system_app_strictmode" : "data_app_strictmode"; 12138 final DropBoxManager dbox = (DropBoxManager) 12139 mContext.getSystemService(Context.DROPBOX_SERVICE); 12140 12141 // Exit early if the dropbox isn't configured to accept this report type. 12142 if (dbox == null || !dbox.isTagEnabled(dropboxTag)) return; 12143 12144 boolean bufferWasEmpty; 12145 boolean needsFlush; 12146 final StringBuilder sb = isSystemApp ? mStrictModeBuffer : new StringBuilder(1024); 12147 synchronized (sb) { 12148 bufferWasEmpty = sb.length() == 0; 12149 appendDropBoxProcessHeaders(process, processName, sb); 12150 sb.append("Build: ").append(Build.FINGERPRINT).append("\n"); 12151 sb.append("System-App: ").append(isSystemApp).append("\n"); 12152 sb.append("Uptime-Millis: ").append(info.violationUptimeMillis).append("\n"); 12153 if (info.violationNumThisLoop != 0) { 12154 sb.append("Loop-Violation-Number: ").append(info.violationNumThisLoop).append("\n"); 12155 } 12156 if (info.numAnimationsRunning != 0) { 12157 sb.append("Animations-Running: ").append(info.numAnimationsRunning).append("\n"); 12158 } 12159 if (info.broadcastIntentAction != null) { 12160 sb.append("Broadcast-Intent-Action: ").append(info.broadcastIntentAction).append("\n"); 12161 } 12162 if (info.durationMillis != -1) { 12163 sb.append("Duration-Millis: ").append(info.durationMillis).append("\n"); 12164 } 12165 if (info.numInstances != -1) { 12166 sb.append("Instance-Count: ").append(info.numInstances).append("\n"); 12167 } 12168 if (info.tags != null) { 12169 for (String tag : info.tags) { 12170 sb.append("Span-Tag: ").append(tag).append("\n"); 12171 } 12172 } 12173 sb.append("\n"); 12174 if (info.crashInfo != null && info.crashInfo.stackTrace != null) { 12175 sb.append(info.crashInfo.stackTrace); 12176 sb.append("\n"); 12177 } 12178 if (info.message != null) { 12179 sb.append(info.message); 12180 sb.append("\n"); 12181 } 12182 12183 // Only buffer up to ~64k. Various logging bits truncate 12184 // things at 128k. 12185 needsFlush = (sb.length() > 64 * 1024); 12186 } 12187 12188 // Flush immediately if the buffer's grown too large, or this 12189 // is a non-system app. Non-system apps are isolated with a 12190 // different tag & policy and not batched. 12191 // 12192 // Batching is useful during internal testing with 12193 // StrictMode settings turned up high. Without batching, 12194 // thousands of separate files could be created on boot. 12195 if (!isSystemApp || needsFlush) { 12196 new Thread("Error dump: " + dropboxTag) { 12197 @Override 12198 public void run() { 12199 String report; 12200 synchronized (sb) { 12201 report = sb.toString(); 12202 sb.delete(0, sb.length()); 12203 sb.trimToSize(); 12204 } 12205 if (report.length() != 0) { 12206 dbox.addText(dropboxTag, report); 12207 } 12208 } 12209 }.start(); 12210 return; 12211 } 12212 12213 // System app batching: 12214 if (!bufferWasEmpty) { 12215 // An existing dropbox-writing thread is outstanding, so 12216 // we don't need to start it up. The existing thread will 12217 // catch the buffer appends we just did. 12218 return; 12219 } 12220 12221 // Worker thread to both batch writes and to avoid blocking the caller on I/O. 12222 // (After this point, we shouldn't access AMS internal data structures.) 12223 new Thread("Error dump: " + dropboxTag) { 12224 @Override 12225 public void run() { 12226 // 5 second sleep to let stacks arrive and be batched together 12227 try { 12228 Thread.sleep(5000); // 5 seconds 12229 } catch (InterruptedException e) {} 12230 12231 String errorReport; 12232 synchronized (mStrictModeBuffer) { 12233 errorReport = mStrictModeBuffer.toString(); 12234 if (errorReport.length() == 0) { 12235 return; 12236 } 12237 mStrictModeBuffer.delete(0, mStrictModeBuffer.length()); 12238 mStrictModeBuffer.trimToSize(); 12239 } 12240 dbox.addText(dropboxTag, errorReport); 12241 } 12242 }.start(); 12243 } 12244 12245 /** 12246 * Used by {@link Log} via {@link com.android.internal.os.RuntimeInit} to report serious errors. 12247 * @param app object of the crashing app, null for the system server 12248 * @param tag reported by the caller 12249 * @param system whether this wtf is coming from the system 12250 * @param crashInfo describing the context of the error 12251 * @return true if the process should exit immediately (WTF is fatal) 12252 */ 12253 public boolean handleApplicationWtf(final IBinder app, final String tag, boolean system, 12254 final ApplicationErrorReport.CrashInfo crashInfo) { 12255 final int callingUid = Binder.getCallingUid(); 12256 final int callingPid = Binder.getCallingPid(); 12257 12258 if (system) { 12259 // If this is coming from the system, we could very well have low-level 12260 // system locks held, so we want to do this all asynchronously. And we 12261 // never want this to become fatal, so there is that too. 12262 mHandler.post(new Runnable() { 12263 @Override public void run() { 12264 handleApplicationWtfInner(callingUid, callingPid, app, tag, crashInfo); 12265 } 12266 }); 12267 return false; 12268 } 12269 12270 final ProcessRecord r = handleApplicationWtfInner(callingUid, callingPid, app, tag, 12271 crashInfo); 12272 12273 if (r != null && r.pid != Process.myPid() && 12274 Settings.Global.getInt(mContext.getContentResolver(), 12275 Settings.Global.WTF_IS_FATAL, 0) != 0) { 12276 crashApplication(r, crashInfo); 12277 return true; 12278 } else { 12279 return false; 12280 } 12281 } 12282 12283 ProcessRecord handleApplicationWtfInner(int callingUid, int callingPid, IBinder app, String tag, 12284 final ApplicationErrorReport.CrashInfo crashInfo) { 12285 final ProcessRecord r = findAppProcess(app, "WTF"); 12286 final String processName = app == null ? "system_server" 12287 : (r == null ? "unknown" : r.processName); 12288 12289 EventLog.writeEvent(EventLogTags.AM_WTF, UserHandle.getUserId(callingUid), callingPid, 12290 processName, r == null ? -1 : r.info.flags, tag, crashInfo.exceptionMessage); 12291 12292 addErrorToDropBox("wtf", r, processName, null, null, tag, null, null, crashInfo); 12293 12294 return r; 12295 } 12296 12297 /** 12298 * @param app object of some object (as stored in {@link com.android.internal.os.RuntimeInit}) 12299 * @return the corresponding {@link ProcessRecord} object, or null if none could be found 12300 */ 12301 private ProcessRecord findAppProcess(IBinder app, String reason) { 12302 if (app == null) { 12303 return null; 12304 } 12305 12306 synchronized (this) { 12307 final int NP = mProcessNames.getMap().size(); 12308 for (int ip=0; ip<NP; ip++) { 12309 SparseArray<ProcessRecord> apps = mProcessNames.getMap().valueAt(ip); 12310 final int NA = apps.size(); 12311 for (int ia=0; ia<NA; ia++) { 12312 ProcessRecord p = apps.valueAt(ia); 12313 if (p.thread != null && p.thread.asBinder() == app) { 12314 return p; 12315 } 12316 } 12317 } 12318 12319 Slog.w(TAG, "Can't find mystery application for " + reason 12320 + " from pid=" + Binder.getCallingPid() 12321 + " uid=" + Binder.getCallingUid() + ": " + app); 12322 return null; 12323 } 12324 } 12325 12326 /** 12327 * Utility function for addErrorToDropBox and handleStrictModeViolation's logging 12328 * to append various headers to the dropbox log text. 12329 */ 12330 private void appendDropBoxProcessHeaders(ProcessRecord process, String processName, 12331 StringBuilder sb) { 12332 // Watchdog thread ends up invoking this function (with 12333 // a null ProcessRecord) to add the stack file to dropbox. 12334 // Do not acquire a lock on this (am) in such cases, as it 12335 // could cause a potential deadlock, if and when watchdog 12336 // is invoked due to unavailability of lock on am and it 12337 // would prevent watchdog from killing system_server. 12338 if (process == null) { 12339 sb.append("Process: ").append(processName).append("\n"); 12340 return; 12341 } 12342 // Note: ProcessRecord 'process' is guarded by the service 12343 // instance. (notably process.pkgList, which could otherwise change 12344 // concurrently during execution of this method) 12345 synchronized (this) { 12346 sb.append("Process: ").append(processName).append("\n"); 12347 int flags = process.info.flags; 12348 IPackageManager pm = AppGlobals.getPackageManager(); 12349 sb.append("Flags: 0x").append(Integer.toString(flags, 16)).append("\n"); 12350 for (int ip=0; ip<process.pkgList.size(); ip++) { 12351 String pkg = process.pkgList.keyAt(ip); 12352 sb.append("Package: ").append(pkg); 12353 try { 12354 PackageInfo pi = pm.getPackageInfo(pkg, 0, UserHandle.getCallingUserId()); 12355 if (pi != null) { 12356 sb.append(" v").append(pi.versionCode); 12357 if (pi.versionName != null) { 12358 sb.append(" (").append(pi.versionName).append(")"); 12359 } 12360 } 12361 } catch (RemoteException e) { 12362 Slog.e(TAG, "Error getting package info: " + pkg, e); 12363 } 12364 sb.append("\n"); 12365 } 12366 } 12367 } 12368 12369 private static String processClass(ProcessRecord process) { 12370 if (process == null || process.pid == MY_PID) { 12371 return "system_server"; 12372 } else if ((process.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0) { 12373 return "system_app"; 12374 } else { 12375 return "data_app"; 12376 } 12377 } 12378 12379 /** 12380 * Write a description of an error (crash, WTF, ANR) to the drop box. 12381 * @param eventType to include in the drop box tag ("crash", "wtf", etc.) 12382 * @param process which caused the error, null means the system server 12383 * @param activity which triggered the error, null if unknown 12384 * @param parent activity related to the error, null if unknown 12385 * @param subject line related to the error, null if absent 12386 * @param report in long form describing the error, null if absent 12387 * @param logFile to include in the report, null if none 12388 * @param crashInfo giving an application stack trace, null if absent 12389 */ 12390 public void addErrorToDropBox(String eventType, 12391 ProcessRecord process, String processName, ActivityRecord activity, 12392 ActivityRecord parent, String subject, 12393 final String report, final File logFile, 12394 final ApplicationErrorReport.CrashInfo crashInfo) { 12395 // NOTE -- this must never acquire the ActivityManagerService lock, 12396 // otherwise the watchdog may be prevented from resetting the system. 12397 12398 final String dropboxTag = processClass(process) + "_" + eventType; 12399 final DropBoxManager dbox = (DropBoxManager) 12400 mContext.getSystemService(Context.DROPBOX_SERVICE); 12401 12402 // Exit early if the dropbox isn't configured to accept this report type. 12403 if (dbox == null || !dbox.isTagEnabled(dropboxTag)) return; 12404 12405 final StringBuilder sb = new StringBuilder(1024); 12406 appendDropBoxProcessHeaders(process, processName, sb); 12407 if (activity != null) { 12408 sb.append("Activity: ").append(activity.shortComponentName).append("\n"); 12409 } 12410 if (parent != null && parent.app != null && parent.app.pid != process.pid) { 12411 sb.append("Parent-Process: ").append(parent.app.processName).append("\n"); 12412 } 12413 if (parent != null && parent != activity) { 12414 sb.append("Parent-Activity: ").append(parent.shortComponentName).append("\n"); 12415 } 12416 if (subject != null) { 12417 sb.append("Subject: ").append(subject).append("\n"); 12418 } 12419 sb.append("Build: ").append(Build.FINGERPRINT).append("\n"); 12420 if (Debug.isDebuggerConnected()) { 12421 sb.append("Debugger: Connected\n"); 12422 } 12423 sb.append("\n"); 12424 12425 // Do the rest in a worker thread to avoid blocking the caller on I/O 12426 // (After this point, we shouldn't access AMS internal data structures.) 12427 Thread worker = new Thread("Error dump: " + dropboxTag) { 12428 @Override 12429 public void run() { 12430 if (report != null) { 12431 sb.append(report); 12432 } 12433 if (logFile != null) { 12434 try { 12435 sb.append(FileUtils.readTextFile(logFile, DROPBOX_MAX_SIZE, 12436 "\n\n[[TRUNCATED]]")); 12437 } catch (IOException e) { 12438 Slog.e(TAG, "Error reading " + logFile, e); 12439 } 12440 } 12441 if (crashInfo != null && crashInfo.stackTrace != null) { 12442 sb.append(crashInfo.stackTrace); 12443 } 12444 12445 String setting = Settings.Global.ERROR_LOGCAT_PREFIX + dropboxTag; 12446 int lines = Settings.Global.getInt(mContext.getContentResolver(), setting, 0); 12447 if (lines > 0) { 12448 sb.append("\n"); 12449 12450 // Merge several logcat streams, and take the last N lines 12451 InputStreamReader input = null; 12452 try { 12453 java.lang.Process logcat = new ProcessBuilder("/system/bin/logcat", 12454 "-v", "time", "-b", "events", "-b", "system", "-b", "main", 12455 "-b", "crash", 12456 "-t", String.valueOf(lines)).redirectErrorStream(true).start(); 12457 12458 try { logcat.getOutputStream().close(); } catch (IOException e) {} 12459 try { logcat.getErrorStream().close(); } catch (IOException e) {} 12460 input = new InputStreamReader(logcat.getInputStream()); 12461 12462 int num; 12463 char[] buf = new char[8192]; 12464 while ((num = input.read(buf)) > 0) sb.append(buf, 0, num); 12465 } catch (IOException e) { 12466 Slog.e(TAG, "Error running logcat", e); 12467 } finally { 12468 if (input != null) try { input.close(); } catch (IOException e) {} 12469 } 12470 } 12471 12472 dbox.addText(dropboxTag, sb.toString()); 12473 } 12474 }; 12475 12476 if (process == null) { 12477 // If process is null, we are being called from some internal code 12478 // and may be about to die -- run this synchronously. 12479 worker.run(); 12480 } else { 12481 worker.start(); 12482 } 12483 } 12484 12485 /** 12486 * Bring up the "unexpected error" dialog box for a crashing app. 12487 * Deal with edge cases (intercepts from instrumented applications, 12488 * ActivityController, error intent receivers, that sort of thing). 12489 * @param r the application crashing 12490 * @param crashInfo describing the failure 12491 */ 12492 private void crashApplication(ProcessRecord r, ApplicationErrorReport.CrashInfo crashInfo) { 12493 long timeMillis = System.currentTimeMillis(); 12494 String shortMsg = crashInfo.exceptionClassName; 12495 String longMsg = crashInfo.exceptionMessage; 12496 String stackTrace = crashInfo.stackTrace; 12497 if (shortMsg != null && longMsg != null) { 12498 longMsg = shortMsg + ": " + longMsg; 12499 } else if (shortMsg != null) { 12500 longMsg = shortMsg; 12501 } 12502 12503 AppErrorResult result = new AppErrorResult(); 12504 synchronized (this) { 12505 if (mController != null) { 12506 try { 12507 String name = r != null ? r.processName : null; 12508 int pid = r != null ? r.pid : Binder.getCallingPid(); 12509 int uid = r != null ? r.info.uid : Binder.getCallingUid(); 12510 if (!mController.appCrashed(name, pid, 12511 shortMsg, longMsg, timeMillis, crashInfo.stackTrace)) { 12512 if ("1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")) 12513 && "Native crash".equals(crashInfo.exceptionClassName)) { 12514 Slog.w(TAG, "Skip killing native crashed app " + name 12515 + "(" + pid + ") during testing"); 12516 } else { 12517 Slog.w(TAG, "Force-killing crashed app " + name 12518 + " at watcher's request"); 12519 if (r != null) { 12520 r.kill("crash", true); 12521 } else { 12522 // Huh. 12523 Process.killProcess(pid); 12524 killProcessGroup(uid, pid); 12525 } 12526 } 12527 return; 12528 } 12529 } catch (RemoteException e) { 12530 mController = null; 12531 Watchdog.getInstance().setActivityController(null); 12532 } 12533 } 12534 12535 final long origId = Binder.clearCallingIdentity(); 12536 12537 // If this process is running instrumentation, finish it. 12538 if (r != null && r.instrumentationClass != null) { 12539 Slog.w(TAG, "Error in app " + r.processName 12540 + " running instrumentation " + r.instrumentationClass + ":"); 12541 if (shortMsg != null) Slog.w(TAG, " " + shortMsg); 12542 if (longMsg != null) Slog.w(TAG, " " + longMsg); 12543 Bundle info = new Bundle(); 12544 info.putString("shortMsg", shortMsg); 12545 info.putString("longMsg", longMsg); 12546 finishInstrumentationLocked(r, Activity.RESULT_CANCELED, info); 12547 Binder.restoreCallingIdentity(origId); 12548 return; 12549 } 12550 12551 // Log crash in battery stats. 12552 if (r != null) { 12553 mBatteryStatsService.noteProcessCrash(r.processName, r.uid); 12554 } 12555 12556 // If we can't identify the process or it's already exceeded its crash quota, 12557 // quit right away without showing a crash dialog. 12558 if (r == null || !makeAppCrashingLocked(r, shortMsg, longMsg, stackTrace)) { 12559 Binder.restoreCallingIdentity(origId); 12560 return; 12561 } 12562 12563 Message msg = Message.obtain(); 12564 msg.what = SHOW_ERROR_MSG; 12565 HashMap data = new HashMap(); 12566 data.put("result", result); 12567 data.put("app", r); 12568 msg.obj = data; 12569 mUiHandler.sendMessage(msg); 12570 12571 Binder.restoreCallingIdentity(origId); 12572 } 12573 12574 int res = result.get(); 12575 12576 Intent appErrorIntent = null; 12577 synchronized (this) { 12578 if (r != null && !r.isolated) { 12579 // XXX Can't keep track of crash time for isolated processes, 12580 // since they don't have a persistent identity. 12581 mProcessCrashTimes.put(r.info.processName, r.uid, 12582 SystemClock.uptimeMillis()); 12583 } 12584 if (res == AppErrorDialog.FORCE_QUIT_AND_REPORT) { 12585 appErrorIntent = createAppErrorIntentLocked(r, timeMillis, crashInfo); 12586 } 12587 } 12588 12589 if (appErrorIntent != null) { 12590 try { 12591 mContext.startActivityAsUser(appErrorIntent, new UserHandle(r.userId)); 12592 } catch (ActivityNotFoundException e) { 12593 Slog.w(TAG, "bug report receiver dissappeared", e); 12594 } 12595 } 12596 } 12597 12598 Intent createAppErrorIntentLocked(ProcessRecord r, 12599 long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) { 12600 ApplicationErrorReport report = createAppErrorReportLocked(r, timeMillis, crashInfo); 12601 if (report == null) { 12602 return null; 12603 } 12604 Intent result = new Intent(Intent.ACTION_APP_ERROR); 12605 result.setComponent(r.errorReportReceiver); 12606 result.putExtra(Intent.EXTRA_BUG_REPORT, report); 12607 result.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 12608 return result; 12609 } 12610 12611 private ApplicationErrorReport createAppErrorReportLocked(ProcessRecord r, 12612 long timeMillis, ApplicationErrorReport.CrashInfo crashInfo) { 12613 if (r.errorReportReceiver == null) { 12614 return null; 12615 } 12616 12617 if (!r.crashing && !r.notResponding && !r.forceCrashReport) { 12618 return null; 12619 } 12620 12621 ApplicationErrorReport report = new ApplicationErrorReport(); 12622 report.packageName = r.info.packageName; 12623 report.installerPackageName = r.errorReportReceiver.getPackageName(); 12624 report.processName = r.processName; 12625 report.time = timeMillis; 12626 report.systemApp = (r.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0; 12627 12628 if (r.crashing || r.forceCrashReport) { 12629 report.type = ApplicationErrorReport.TYPE_CRASH; 12630 report.crashInfo = crashInfo; 12631 } else if (r.notResponding) { 12632 report.type = ApplicationErrorReport.TYPE_ANR; 12633 report.anrInfo = new ApplicationErrorReport.AnrInfo(); 12634 12635 report.anrInfo.activity = r.notRespondingReport.tag; 12636 report.anrInfo.cause = r.notRespondingReport.shortMsg; 12637 report.anrInfo.info = r.notRespondingReport.longMsg; 12638 } 12639 12640 return report; 12641 } 12642 12643 public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState() { 12644 enforceNotIsolatedCaller("getProcessesInErrorState"); 12645 // assume our apps are happy - lazy create the list 12646 List<ActivityManager.ProcessErrorStateInfo> errList = null; 12647 12648 final boolean allUsers = ActivityManager.checkUidPermission(INTERACT_ACROSS_USERS_FULL, 12649 Binder.getCallingUid()) == PackageManager.PERMISSION_GRANTED; 12650 int userId = UserHandle.getUserId(Binder.getCallingUid()); 12651 12652 synchronized (this) { 12653 12654 // iterate across all processes 12655 for (int i=mLruProcesses.size()-1; i>=0; i--) { 12656 ProcessRecord app = mLruProcesses.get(i); 12657 if (!allUsers && app.userId != userId) { 12658 continue; 12659 } 12660 if ((app.thread != null) && (app.crashing || app.notResponding)) { 12661 // This one's in trouble, so we'll generate a report for it 12662 // crashes are higher priority (in case there's a crash *and* an anr) 12663 ActivityManager.ProcessErrorStateInfo report = null; 12664 if (app.crashing) { 12665 report = app.crashingReport; 12666 } else if (app.notResponding) { 12667 report = app.notRespondingReport; 12668 } 12669 12670 if (report != null) { 12671 if (errList == null) { 12672 errList = new ArrayList<ActivityManager.ProcessErrorStateInfo>(1); 12673 } 12674 errList.add(report); 12675 } else { 12676 Slog.w(TAG, "Missing app error report, app = " + app.processName + 12677 " crashing = " + app.crashing + 12678 " notResponding = " + app.notResponding); 12679 } 12680 } 12681 } 12682 } 12683 12684 return errList; 12685 } 12686 12687 static int procStateToImportance(int procState, int memAdj, 12688 ActivityManager.RunningAppProcessInfo currApp) { 12689 int imp = ActivityManager.RunningAppProcessInfo.procStateToImportance(procState); 12690 if (imp == ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND) { 12691 currApp.lru = memAdj; 12692 } else { 12693 currApp.lru = 0; 12694 } 12695 return imp; 12696 } 12697 12698 private void fillInProcMemInfo(ProcessRecord app, 12699 ActivityManager.RunningAppProcessInfo outInfo) { 12700 outInfo.pid = app.pid; 12701 outInfo.uid = app.info.uid; 12702 if (mHeavyWeightProcess == app) { 12703 outInfo.flags |= ActivityManager.RunningAppProcessInfo.FLAG_CANT_SAVE_STATE; 12704 } 12705 if (app.persistent) { 12706 outInfo.flags |= ActivityManager.RunningAppProcessInfo.FLAG_PERSISTENT; 12707 } 12708 if (app.activities.size() > 0) { 12709 outInfo.flags |= ActivityManager.RunningAppProcessInfo.FLAG_HAS_ACTIVITIES; 12710 } 12711 outInfo.lastTrimLevel = app.trimMemoryLevel; 12712 int adj = app.curAdj; 12713 int procState = app.curProcState; 12714 outInfo.importance = procStateToImportance(procState, adj, outInfo); 12715 outInfo.importanceReasonCode = app.adjTypeCode; 12716 outInfo.processState = app.curProcState; 12717 } 12718 12719 public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses() { 12720 enforceNotIsolatedCaller("getRunningAppProcesses"); 12721 12722 final int callingUid = Binder.getCallingUid(); 12723 12724 // Lazy instantiation of list 12725 List<ActivityManager.RunningAppProcessInfo> runList = null; 12726 final boolean allUsers = ActivityManager.checkUidPermission(INTERACT_ACROSS_USERS_FULL, 12727 callingUid) == PackageManager.PERMISSION_GRANTED; 12728 final int userId = UserHandle.getUserId(callingUid); 12729 final boolean allUids = isGetTasksAllowed( 12730 "getRunningAppProcesses", Binder.getCallingPid(), callingUid); 12731 12732 synchronized (this) { 12733 // Iterate across all processes 12734 for (int i = mLruProcesses.size() - 1; i >= 0; i--) { 12735 ProcessRecord app = mLruProcesses.get(i); 12736 if ((!allUsers && app.userId != userId) 12737 || (!allUids && app.uid != callingUid)) { 12738 continue; 12739 } 12740 if ((app.thread != null) && (!app.crashing && !app.notResponding)) { 12741 // Generate process state info for running application 12742 ActivityManager.RunningAppProcessInfo currApp = 12743 new ActivityManager.RunningAppProcessInfo(app.processName, 12744 app.pid, app.getPackageList()); 12745 fillInProcMemInfo(app, currApp); 12746 if (app.adjSource instanceof ProcessRecord) { 12747 currApp.importanceReasonPid = ((ProcessRecord)app.adjSource).pid; 12748 currApp.importanceReasonImportance = 12749 ActivityManager.RunningAppProcessInfo.procStateToImportance( 12750 app.adjSourceProcState); 12751 } else if (app.adjSource instanceof ActivityRecord) { 12752 ActivityRecord r = (ActivityRecord)app.adjSource; 12753 if (r.app != null) currApp.importanceReasonPid = r.app.pid; 12754 } 12755 if (app.adjTarget instanceof ComponentName) { 12756 currApp.importanceReasonComponent = (ComponentName)app.adjTarget; 12757 } 12758 //Slog.v(TAG, "Proc " + app.processName + ": imp=" + currApp.importance 12759 // + " lru=" + currApp.lru); 12760 if (runList == null) { 12761 runList = new ArrayList<>(); 12762 } 12763 runList.add(currApp); 12764 } 12765 } 12766 } 12767 return runList; 12768 } 12769 12770 public List<ApplicationInfo> getRunningExternalApplications() { 12771 enforceNotIsolatedCaller("getRunningExternalApplications"); 12772 List<ActivityManager.RunningAppProcessInfo> runningApps = getRunningAppProcesses(); 12773 List<ApplicationInfo> retList = new ArrayList<ApplicationInfo>(); 12774 if (runningApps != null && runningApps.size() > 0) { 12775 Set<String> extList = new HashSet<String>(); 12776 for (ActivityManager.RunningAppProcessInfo app : runningApps) { 12777 if (app.pkgList != null) { 12778 for (String pkg : app.pkgList) { 12779 extList.add(pkg); 12780 } 12781 } 12782 } 12783 IPackageManager pm = AppGlobals.getPackageManager(); 12784 for (String pkg : extList) { 12785 try { 12786 ApplicationInfo info = pm.getApplicationInfo(pkg, 0, UserHandle.getCallingUserId()); 12787 if ((info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0) { 12788 retList.add(info); 12789 } 12790 } catch (RemoteException e) { 12791 } 12792 } 12793 } 12794 return retList; 12795 } 12796 12797 @Override 12798 public void getMyMemoryState(ActivityManager.RunningAppProcessInfo outInfo) { 12799 enforceNotIsolatedCaller("getMyMemoryState"); 12800 synchronized (this) { 12801 ProcessRecord proc; 12802 synchronized (mPidsSelfLocked) { 12803 proc = mPidsSelfLocked.get(Binder.getCallingPid()); 12804 } 12805 fillInProcMemInfo(proc, outInfo); 12806 } 12807 } 12808 12809 @Override 12810 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 12811 if (checkCallingPermission(android.Manifest.permission.DUMP) 12812 != PackageManager.PERMISSION_GRANTED) { 12813 pw.println("Permission Denial: can't dump ActivityManager from from pid=" 12814 + Binder.getCallingPid() 12815 + ", uid=" + Binder.getCallingUid() 12816 + " without permission " 12817 + android.Manifest.permission.DUMP); 12818 return; 12819 } 12820 12821 boolean dumpAll = false; 12822 boolean dumpClient = false; 12823 String dumpPackage = null; 12824 12825 int opti = 0; 12826 while (opti < args.length) { 12827 String opt = args[opti]; 12828 if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') { 12829 break; 12830 } 12831 opti++; 12832 if ("-a".equals(opt)) { 12833 dumpAll = true; 12834 } else if ("-c".equals(opt)) { 12835 dumpClient = true; 12836 } else if ("-p".equals(opt)) { 12837 if (opti < args.length) { 12838 dumpPackage = args[opti]; 12839 opti++; 12840 } else { 12841 pw.println("Error: -p option requires package argument"); 12842 return; 12843 } 12844 dumpClient = true; 12845 } else if ("-h".equals(opt)) { 12846 pw.println("Activity manager dump options:"); 12847 pw.println(" [-a] [-c] [-p package] [-h] [cmd] ..."); 12848 pw.println(" cmd may be one of:"); 12849 pw.println(" a[ctivities]: activity stack state"); 12850 pw.println(" r[recents]: recent activities state"); 12851 pw.println(" b[roadcasts] [PACKAGE_NAME] [history [-s]]: broadcast state"); 12852 pw.println(" i[ntents] [PACKAGE_NAME]: pending intent state"); 12853 pw.println(" p[rocesses] [PACKAGE_NAME]: process state"); 12854 pw.println(" o[om]: out of memory management"); 12855 pw.println(" perm[issions]: URI permission grant state"); 12856 pw.println(" prov[iders] [COMP_SPEC ...]: content provider state"); 12857 pw.println(" provider [COMP_SPEC]: provider client-side state"); 12858 pw.println(" s[ervices] [COMP_SPEC ...]: service state"); 12859 pw.println(" as[sociations]: tracked app associations"); 12860 pw.println(" service [COMP_SPEC]: service client-side state"); 12861 pw.println(" package [PACKAGE_NAME]: all state related to given package"); 12862 pw.println(" all: dump all activities"); 12863 pw.println(" top: dump the top activity"); 12864 pw.println(" write: write all pending state to storage"); 12865 pw.println(" track-associations: enable association tracking"); 12866 pw.println(" untrack-associations: disable and clear association tracking"); 12867 pw.println(" cmd may also be a COMP_SPEC to dump activities."); 12868 pw.println(" COMP_SPEC may be a component name (com.foo/.myApp),"); 12869 pw.println(" a partial substring in a component name, a"); 12870 pw.println(" hex object identifier."); 12871 pw.println(" -a: include all available server state."); 12872 pw.println(" -c: include client state."); 12873 pw.println(" -p: limit output to given package."); 12874 return; 12875 } else { 12876 pw.println("Unknown argument: " + opt + "; use -h for help"); 12877 } 12878 } 12879 12880 long origId = Binder.clearCallingIdentity(); 12881 boolean more = false; 12882 // Is the caller requesting to dump a particular piece of data? 12883 if (opti < args.length) { 12884 String cmd = args[opti]; 12885 opti++; 12886 if ("activities".equals(cmd) || "a".equals(cmd)) { 12887 synchronized (this) { 12888 dumpActivitiesLocked(fd, pw, args, opti, true, dumpClient, dumpPackage); 12889 } 12890 } else if ("recents".equals(cmd) || "r".equals(cmd)) { 12891 synchronized (this) { 12892 dumpRecentsLocked(fd, pw, args, opti, true, dumpPackage); 12893 } 12894 } else if ("broadcasts".equals(cmd) || "b".equals(cmd)) { 12895 String[] newArgs; 12896 String name; 12897 if (opti >= args.length) { 12898 name = null; 12899 newArgs = EMPTY_STRING_ARRAY; 12900 } else { 12901 dumpPackage = args[opti]; 12902 opti++; 12903 newArgs = new String[args.length - opti]; 12904 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, 12905 args.length - opti); 12906 } 12907 synchronized (this) { 12908 dumpBroadcastsLocked(fd, pw, args, opti, true, dumpPackage); 12909 } 12910 } else if ("intents".equals(cmd) || "i".equals(cmd)) { 12911 String[] newArgs; 12912 String name; 12913 if (opti >= args.length) { 12914 name = null; 12915 newArgs = EMPTY_STRING_ARRAY; 12916 } else { 12917 dumpPackage = args[opti]; 12918 opti++; 12919 newArgs = new String[args.length - opti]; 12920 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, 12921 args.length - opti); 12922 } 12923 synchronized (this) { 12924 dumpPendingIntentsLocked(fd, pw, args, opti, true, dumpPackage); 12925 } 12926 } else if ("processes".equals(cmd) || "p".equals(cmd)) { 12927 String[] newArgs; 12928 String name; 12929 if (opti >= args.length) { 12930 name = null; 12931 newArgs = EMPTY_STRING_ARRAY; 12932 } else { 12933 dumpPackage = args[opti]; 12934 opti++; 12935 newArgs = new String[args.length - opti]; 12936 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, 12937 args.length - opti); 12938 } 12939 synchronized (this) { 12940 dumpProcessesLocked(fd, pw, args, opti, true, dumpPackage); 12941 } 12942 } else if ("oom".equals(cmd) || "o".equals(cmd)) { 12943 synchronized (this) { 12944 dumpOomLocked(fd, pw, args, opti, true); 12945 } 12946 } else if ("permissions".equals(cmd) || "perm".equals(cmd)) { 12947 synchronized (this) { 12948 dumpPermissionsLocked(fd, pw, args, opti, true, null); 12949 } 12950 } else if ("provider".equals(cmd)) { 12951 String[] newArgs; 12952 String name; 12953 if (opti >= args.length) { 12954 name = null; 12955 newArgs = EMPTY_STRING_ARRAY; 12956 } else { 12957 name = args[opti]; 12958 opti++; 12959 newArgs = new String[args.length - opti]; 12960 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, args.length - opti); 12961 } 12962 if (!dumpProvider(fd, pw, name, newArgs, 0, dumpAll)) { 12963 pw.println("No providers match: " + name); 12964 pw.println("Use -h for help."); 12965 } 12966 } else if ("providers".equals(cmd) || "prov".equals(cmd)) { 12967 synchronized (this) { 12968 dumpProvidersLocked(fd, pw, args, opti, true, null); 12969 } 12970 } else if ("service".equals(cmd)) { 12971 String[] newArgs; 12972 String name; 12973 if (opti >= args.length) { 12974 name = null; 12975 newArgs = EMPTY_STRING_ARRAY; 12976 } else { 12977 name = args[opti]; 12978 opti++; 12979 newArgs = new String[args.length - opti]; 12980 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, 12981 args.length - opti); 12982 } 12983 if (!mServices.dumpService(fd, pw, name, newArgs, 0, dumpAll)) { 12984 pw.println("No services match: " + name); 12985 pw.println("Use -h for help."); 12986 } 12987 } else if ("package".equals(cmd)) { 12988 String[] newArgs; 12989 if (opti >= args.length) { 12990 pw.println("package: no package name specified"); 12991 pw.println("Use -h for help."); 12992 } else { 12993 dumpPackage = args[opti]; 12994 opti++; 12995 newArgs = new String[args.length - opti]; 12996 if (args.length > 2) System.arraycopy(args, opti, newArgs, 0, 12997 args.length - opti); 12998 args = newArgs; 12999 opti = 0; 13000 more = true; 13001 } 13002 } else if ("associations".equals(cmd) || "as".equals(cmd)) { 13003 synchronized (this) { 13004 dumpAssociationsLocked(fd, pw, args, opti, true, dumpClient, dumpPackage); 13005 } 13006 } else if ("services".equals(cmd) || "s".equals(cmd)) { 13007 synchronized (this) { 13008 mServices.dumpServicesLocked(fd, pw, args, opti, true, dumpClient, dumpPackage); 13009 } 13010 } else if ("write".equals(cmd)) { 13011 mTaskPersister.flush(); 13012 pw.println("All tasks persisted."); 13013 return; 13014 } else if ("track-associations".equals(cmd)) { 13015 synchronized (this) { 13016 if (!mTrackingAssociations) { 13017 mTrackingAssociations = true; 13018 pw.println("Association tracking started."); 13019 } else { 13020 pw.println("Association tracking already enabled."); 13021 } 13022 } 13023 return; 13024 } else if ("untrack-associations".equals(cmd)) { 13025 synchronized (this) { 13026 if (mTrackingAssociations) { 13027 mTrackingAssociations = false; 13028 mAssociations.clear(); 13029 pw.println("Association tracking stopped."); 13030 } else { 13031 pw.println("Association tracking not running."); 13032 } 13033 } 13034 return; 13035 } else { 13036 // Dumping a single activity? 13037 if (!dumpActivity(fd, pw, cmd, args, opti, dumpAll)) { 13038 pw.println("Bad activity command, or no activities match: " + cmd); 13039 pw.println("Use -h for help."); 13040 } 13041 } 13042 if (!more) { 13043 Binder.restoreCallingIdentity(origId); 13044 return; 13045 } 13046 } 13047 13048 // No piece of data specified, dump everything. 13049 synchronized (this) { 13050 dumpPendingIntentsLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13051 pw.println(); 13052 if (dumpAll) { 13053 pw.println("-------------------------------------------------------------------------------"); 13054 } 13055 dumpBroadcastsLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13056 pw.println(); 13057 if (dumpAll) { 13058 pw.println("-------------------------------------------------------------------------------"); 13059 } 13060 dumpProvidersLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13061 pw.println(); 13062 if (dumpAll) { 13063 pw.println("-------------------------------------------------------------------------------"); 13064 } 13065 dumpPermissionsLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13066 pw.println(); 13067 if (dumpAll) { 13068 pw.println("-------------------------------------------------------------------------------"); 13069 } 13070 mServices.dumpServicesLocked(fd, pw, args, opti, dumpAll, dumpClient, dumpPackage); 13071 pw.println(); 13072 if (dumpAll) { 13073 pw.println("-------------------------------------------------------------------------------"); 13074 } 13075 dumpRecentsLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13076 pw.println(); 13077 if (dumpAll) { 13078 pw.println("-------------------------------------------------------------------------------"); 13079 } 13080 dumpActivitiesLocked(fd, pw, args, opti, dumpAll, dumpClient, dumpPackage); 13081 if (mAssociations.size() > 0) { 13082 pw.println(); 13083 if (dumpAll) { 13084 pw.println("-------------------------------------------------------------------------------"); 13085 } 13086 dumpAssociationsLocked(fd, pw, args, opti, dumpAll, dumpClient, dumpPackage); 13087 } 13088 pw.println(); 13089 if (dumpAll) { 13090 pw.println("-------------------------------------------------------------------------------"); 13091 } 13092 dumpProcessesLocked(fd, pw, args, opti, dumpAll, dumpPackage); 13093 } 13094 Binder.restoreCallingIdentity(origId); 13095 } 13096 13097 void dumpActivitiesLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13098 int opti, boolean dumpAll, boolean dumpClient, String dumpPackage) { 13099 pw.println("ACTIVITY MANAGER ACTIVITIES (dumpsys activity activities)"); 13100 13101 boolean printedAnything = mStackSupervisor.dumpActivitiesLocked(fd, pw, dumpAll, dumpClient, 13102 dumpPackage); 13103 boolean needSep = printedAnything; 13104 13105 boolean printed = ActivityStackSupervisor.printThisActivity(pw, mFocusedActivity, 13106 dumpPackage, needSep, " mFocusedActivity: "); 13107 if (printed) { 13108 printedAnything = true; 13109 needSep = false; 13110 } 13111 13112 if (dumpPackage == null) { 13113 if (needSep) { 13114 pw.println(); 13115 } 13116 needSep = true; 13117 printedAnything = true; 13118 mStackSupervisor.dump(pw, " "); 13119 } 13120 13121 if (!printedAnything) { 13122 pw.println(" (nothing)"); 13123 } 13124 } 13125 13126 void dumpRecentsLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13127 int opti, boolean dumpAll, String dumpPackage) { 13128 pw.println("ACTIVITY MANAGER RECENT TASKS (dumpsys activity recents)"); 13129 13130 boolean printedAnything = false; 13131 13132 if (mRecentTasks != null && mRecentTasks.size() > 0) { 13133 boolean printedHeader = false; 13134 13135 final int N = mRecentTasks.size(); 13136 for (int i=0; i<N; i++) { 13137 TaskRecord tr = mRecentTasks.get(i); 13138 if (dumpPackage != null) { 13139 if (tr.realActivity == null || 13140 !dumpPackage.equals(tr.realActivity)) { 13141 continue; 13142 } 13143 } 13144 if (!printedHeader) { 13145 pw.println(" Recent tasks:"); 13146 printedHeader = true; 13147 printedAnything = true; 13148 } 13149 pw.print(" * Recent #"); pw.print(i); pw.print(": "); 13150 pw.println(tr); 13151 if (dumpAll) { 13152 mRecentTasks.get(i).dump(pw, " "); 13153 } 13154 } 13155 } 13156 13157 if (!printedAnything) { 13158 pw.println(" (nothing)"); 13159 } 13160 } 13161 13162 void dumpAssociationsLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13163 int opti, boolean dumpAll, boolean dumpClient, String dumpPackage) { 13164 pw.println("ACTIVITY MANAGER ASSOCIATIONS (dumpsys activity associations)"); 13165 13166 int dumpUid = 0; 13167 if (dumpPackage != null) { 13168 IPackageManager pm = AppGlobals.getPackageManager(); 13169 try { 13170 dumpUid = pm.getPackageUid(dumpPackage, 0); 13171 } catch (RemoteException e) { 13172 } 13173 } 13174 13175 boolean printedAnything = false; 13176 13177 final long now = SystemClock.uptimeMillis(); 13178 13179 for (int i1=0, N1=mAssociations.size(); i1<N1; i1++) { 13180 ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>> targetComponents 13181 = mAssociations.valueAt(i1); 13182 for (int i2=0, N2=targetComponents.size(); i2<N2; i2++) { 13183 SparseArray<ArrayMap<String, Association>> sourceUids 13184 = targetComponents.valueAt(i2); 13185 for (int i3=0, N3=sourceUids.size(); i3<N3; i3++) { 13186 ArrayMap<String, Association> sourceProcesses = sourceUids.valueAt(i3); 13187 for (int i4=0, N4=sourceProcesses.size(); i4<N4; i4++) { 13188 Association ass = sourceProcesses.valueAt(i4); 13189 if (dumpPackage != null) { 13190 if (!ass.mTargetComponent.getPackageName().equals(dumpPackage) 13191 && UserHandle.getAppId(ass.mSourceUid) != dumpUid) { 13192 continue; 13193 } 13194 } 13195 printedAnything = true; 13196 pw.print(" "); 13197 pw.print(ass.mTargetProcess); 13198 pw.print("/"); 13199 UserHandle.formatUid(pw, ass.mTargetUid); 13200 pw.print(" <- "); 13201 pw.print(ass.mSourceProcess); 13202 pw.print("/"); 13203 UserHandle.formatUid(pw, ass.mSourceUid); 13204 pw.println(); 13205 pw.print(" via "); 13206 pw.print(ass.mTargetComponent.flattenToShortString()); 13207 pw.println(); 13208 pw.print(" "); 13209 long dur = ass.mTime; 13210 if (ass.mNesting > 0) { 13211 dur += now - ass.mStartTime; 13212 } 13213 TimeUtils.formatDuration(dur, pw); 13214 pw.print(" ("); 13215 pw.print(ass.mCount); 13216 pw.println(" times)"); 13217 if (ass.mNesting > 0) { 13218 pw.print(" "); 13219 pw.print(" Currently active: "); 13220 TimeUtils.formatDuration(now - ass.mStartTime, pw); 13221 pw.println(); 13222 } 13223 } 13224 } 13225 } 13226 13227 } 13228 13229 if (!printedAnything) { 13230 pw.println(" (nothing)"); 13231 } 13232 } 13233 13234 void dumpProcessesLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13235 int opti, boolean dumpAll, String dumpPackage) { 13236 boolean needSep = false; 13237 boolean printedAnything = false; 13238 int numPers = 0; 13239 13240 pw.println("ACTIVITY MANAGER RUNNING PROCESSES (dumpsys activity processes)"); 13241 13242 if (dumpAll) { 13243 final int NP = mProcessNames.getMap().size(); 13244 for (int ip=0; ip<NP; ip++) { 13245 SparseArray<ProcessRecord> procs = mProcessNames.getMap().valueAt(ip); 13246 final int NA = procs.size(); 13247 for (int ia=0; ia<NA; ia++) { 13248 ProcessRecord r = procs.valueAt(ia); 13249 if (dumpPackage != null && !r.pkgList.containsKey(dumpPackage)) { 13250 continue; 13251 } 13252 if (!needSep) { 13253 pw.println(" All known processes:"); 13254 needSep = true; 13255 printedAnything = true; 13256 } 13257 pw.print(r.persistent ? " *PERS*" : " *APP*"); 13258 pw.print(" UID "); pw.print(procs.keyAt(ia)); 13259 pw.print(" "); pw.println(r); 13260 r.dump(pw, " "); 13261 if (r.persistent) { 13262 numPers++; 13263 } 13264 } 13265 } 13266 } 13267 13268 if (mIsolatedProcesses.size() > 0) { 13269 boolean printed = false; 13270 for (int i=0; i<mIsolatedProcesses.size(); i++) { 13271 ProcessRecord r = mIsolatedProcesses.valueAt(i); 13272 if (dumpPackage != null && !r.pkgList.containsKey(dumpPackage)) { 13273 continue; 13274 } 13275 if (!printed) { 13276 if (needSep) { 13277 pw.println(); 13278 } 13279 pw.println(" Isolated process list (sorted by uid):"); 13280 printedAnything = true; 13281 printed = true; 13282 needSep = true; 13283 } 13284 pw.println(String.format("%sIsolated #%2d: %s", 13285 " ", i, r.toString())); 13286 } 13287 } 13288 13289 if (mActiveUids.size() > 0) { 13290 if (needSep) { 13291 pw.println(); 13292 } 13293 pw.println(" UID states:"); 13294 for (int i=0; i<mActiveUids.size(); i++) { 13295 UidRecord uidRec = mActiveUids.valueAt(i); 13296 pw.print(" UID "); UserHandle.formatUid(pw, uidRec.uid); 13297 pw.print(": "); pw.println(uidRec); 13298 } 13299 needSep = true; 13300 printedAnything = true; 13301 } 13302 13303 if (mLruProcesses.size() > 0) { 13304 if (needSep) { 13305 pw.println(); 13306 } 13307 pw.print(" Process LRU list (sorted by oom_adj, "); pw.print(mLruProcesses.size()); 13308 pw.print(" total, non-act at "); 13309 pw.print(mLruProcesses.size()-mLruProcessActivityStart); 13310 pw.print(", non-svc at "); 13311 pw.print(mLruProcesses.size()-mLruProcessServiceStart); 13312 pw.println("):"); 13313 dumpProcessOomList(pw, this, mLruProcesses, " ", "Proc", "PERS", false, dumpPackage); 13314 needSep = true; 13315 printedAnything = true; 13316 } 13317 13318 if (dumpAll || dumpPackage != null) { 13319 synchronized (mPidsSelfLocked) { 13320 boolean printed = false; 13321 for (int i=0; i<mPidsSelfLocked.size(); i++) { 13322 ProcessRecord r = mPidsSelfLocked.valueAt(i); 13323 if (dumpPackage != null && !r.pkgList.containsKey(dumpPackage)) { 13324 continue; 13325 } 13326 if (!printed) { 13327 if (needSep) pw.println(); 13328 needSep = true; 13329 pw.println(" PID mappings:"); 13330 printed = true; 13331 printedAnything = true; 13332 } 13333 pw.print(" PID #"); pw.print(mPidsSelfLocked.keyAt(i)); 13334 pw.print(": "); pw.println(mPidsSelfLocked.valueAt(i)); 13335 } 13336 } 13337 } 13338 13339 if (mForegroundProcesses.size() > 0) { 13340 synchronized (mPidsSelfLocked) { 13341 boolean printed = false; 13342 for (int i=0; i<mForegroundProcesses.size(); i++) { 13343 ProcessRecord r = mPidsSelfLocked.get( 13344 mForegroundProcesses.valueAt(i).pid); 13345 if (dumpPackage != null && (r == null 13346 || !r.pkgList.containsKey(dumpPackage))) { 13347 continue; 13348 } 13349 if (!printed) { 13350 if (needSep) pw.println(); 13351 needSep = true; 13352 pw.println(" Foreground Processes:"); 13353 printed = true; 13354 printedAnything = true; 13355 } 13356 pw.print(" PID #"); pw.print(mForegroundProcesses.keyAt(i)); 13357 pw.print(": "); pw.println(mForegroundProcesses.valueAt(i)); 13358 } 13359 } 13360 } 13361 13362 if (mPersistentStartingProcesses.size() > 0) { 13363 if (needSep) pw.println(); 13364 needSep = true; 13365 printedAnything = true; 13366 pw.println(" Persisent processes that are starting:"); 13367 dumpProcessList(pw, this, mPersistentStartingProcesses, " ", 13368 "Starting Norm", "Restarting PERS", dumpPackage); 13369 } 13370 13371 if (mRemovedProcesses.size() > 0) { 13372 if (needSep) pw.println(); 13373 needSep = true; 13374 printedAnything = true; 13375 pw.println(" Processes that are being removed:"); 13376 dumpProcessList(pw, this, mRemovedProcesses, " ", 13377 "Removed Norm", "Removed PERS", dumpPackage); 13378 } 13379 13380 if (mProcessesOnHold.size() > 0) { 13381 if (needSep) pw.println(); 13382 needSep = true; 13383 printedAnything = true; 13384 pw.println(" Processes that are on old until the system is ready:"); 13385 dumpProcessList(pw, this, mProcessesOnHold, " ", 13386 "OnHold Norm", "OnHold PERS", dumpPackage); 13387 } 13388 13389 needSep = dumpProcessesToGc(fd, pw, args, opti, needSep, dumpAll, dumpPackage); 13390 13391 if (mProcessCrashTimes.getMap().size() > 0) { 13392 boolean printed = false; 13393 long now = SystemClock.uptimeMillis(); 13394 final ArrayMap<String, SparseArray<Long>> pmap = mProcessCrashTimes.getMap(); 13395 final int NP = pmap.size(); 13396 for (int ip=0; ip<NP; ip++) { 13397 String pname = pmap.keyAt(ip); 13398 SparseArray<Long> uids = pmap.valueAt(ip); 13399 final int N = uids.size(); 13400 for (int i=0; i<N; i++) { 13401 int puid = uids.keyAt(i); 13402 ProcessRecord r = mProcessNames.get(pname, puid); 13403 if (dumpPackage != null && (r == null 13404 || !r.pkgList.containsKey(dumpPackage))) { 13405 continue; 13406 } 13407 if (!printed) { 13408 if (needSep) pw.println(); 13409 needSep = true; 13410 pw.println(" Time since processes crashed:"); 13411 printed = true; 13412 printedAnything = true; 13413 } 13414 pw.print(" Process "); pw.print(pname); 13415 pw.print(" uid "); pw.print(puid); 13416 pw.print(": last crashed "); 13417 TimeUtils.formatDuration(now-uids.valueAt(i), pw); 13418 pw.println(" ago"); 13419 } 13420 } 13421 } 13422 13423 if (mBadProcesses.getMap().size() > 0) { 13424 boolean printed = false; 13425 final ArrayMap<String, SparseArray<BadProcessInfo>> pmap = mBadProcesses.getMap(); 13426 final int NP = pmap.size(); 13427 for (int ip=0; ip<NP; ip++) { 13428 String pname = pmap.keyAt(ip); 13429 SparseArray<BadProcessInfo> uids = pmap.valueAt(ip); 13430 final int N = uids.size(); 13431 for (int i=0; i<N; i++) { 13432 int puid = uids.keyAt(i); 13433 ProcessRecord r = mProcessNames.get(pname, puid); 13434 if (dumpPackage != null && (r == null 13435 || !r.pkgList.containsKey(dumpPackage))) { 13436 continue; 13437 } 13438 if (!printed) { 13439 if (needSep) pw.println(); 13440 needSep = true; 13441 pw.println(" Bad processes:"); 13442 printedAnything = true; 13443 } 13444 BadProcessInfo info = uids.valueAt(i); 13445 pw.print(" Bad process "); pw.print(pname); 13446 pw.print(" uid "); pw.print(puid); 13447 pw.print(": crashed at time "); pw.println(info.time); 13448 if (info.shortMsg != null) { 13449 pw.print(" Short msg: "); pw.println(info.shortMsg); 13450 } 13451 if (info.longMsg != null) { 13452 pw.print(" Long msg: "); pw.println(info.longMsg); 13453 } 13454 if (info.stack != null) { 13455 pw.println(" Stack:"); 13456 int lastPos = 0; 13457 for (int pos=0; pos<info.stack.length(); pos++) { 13458 if (info.stack.charAt(pos) == '\n') { 13459 pw.print(" "); 13460 pw.write(info.stack, lastPos, pos-lastPos); 13461 pw.println(); 13462 lastPos = pos+1; 13463 } 13464 } 13465 if (lastPos < info.stack.length()) { 13466 pw.print(" "); 13467 pw.write(info.stack, lastPos, info.stack.length()-lastPos); 13468 pw.println(); 13469 } 13470 } 13471 } 13472 } 13473 } 13474 13475 if (dumpPackage == null) { 13476 pw.println(); 13477 needSep = false; 13478 pw.println(" mStartedUsers:"); 13479 for (int i=0; i<mStartedUsers.size(); i++) { 13480 UserState uss = mStartedUsers.valueAt(i); 13481 pw.print(" User #"); pw.print(uss.mHandle.getIdentifier()); 13482 pw.print(": "); uss.dump("", pw); 13483 } 13484 pw.print(" mStartedUserArray: ["); 13485 for (int i=0; i<mStartedUserArray.length; i++) { 13486 if (i > 0) pw.print(", "); 13487 pw.print(mStartedUserArray[i]); 13488 } 13489 pw.println("]"); 13490 pw.print(" mUserLru: ["); 13491 for (int i=0; i<mUserLru.size(); i++) { 13492 if (i > 0) pw.print(", "); 13493 pw.print(mUserLru.get(i)); 13494 } 13495 pw.println("]"); 13496 if (dumpAll) { 13497 pw.print(" mStartedUserArray: "); pw.println(Arrays.toString(mStartedUserArray)); 13498 } 13499 synchronized (mUserProfileGroupIdsSelfLocked) { 13500 if (mUserProfileGroupIdsSelfLocked.size() > 0) { 13501 pw.println(" mUserProfileGroupIds:"); 13502 for (int i=0; i<mUserProfileGroupIdsSelfLocked.size(); i++) { 13503 pw.print(" User #"); 13504 pw.print(mUserProfileGroupIdsSelfLocked.keyAt(i)); 13505 pw.print(" -> profile #"); 13506 pw.println(mUserProfileGroupIdsSelfLocked.valueAt(i)); 13507 } 13508 } 13509 } 13510 } 13511 if (mHomeProcess != null && (dumpPackage == null 13512 || mHomeProcess.pkgList.containsKey(dumpPackage))) { 13513 if (needSep) { 13514 pw.println(); 13515 needSep = false; 13516 } 13517 pw.println(" mHomeProcess: " + mHomeProcess); 13518 } 13519 if (mPreviousProcess != null && (dumpPackage == null 13520 || mPreviousProcess.pkgList.containsKey(dumpPackage))) { 13521 if (needSep) { 13522 pw.println(); 13523 needSep = false; 13524 } 13525 pw.println(" mPreviousProcess: " + mPreviousProcess); 13526 } 13527 if (dumpAll) { 13528 StringBuilder sb = new StringBuilder(128); 13529 sb.append(" mPreviousProcessVisibleTime: "); 13530 TimeUtils.formatDuration(mPreviousProcessVisibleTime, sb); 13531 pw.println(sb); 13532 } 13533 if (mHeavyWeightProcess != null && (dumpPackage == null 13534 || mHeavyWeightProcess.pkgList.containsKey(dumpPackage))) { 13535 if (needSep) { 13536 pw.println(); 13537 needSep = false; 13538 } 13539 pw.println(" mHeavyWeightProcess: " + mHeavyWeightProcess); 13540 } 13541 if (dumpPackage == null) { 13542 pw.println(" mConfiguration: " + mConfiguration); 13543 } 13544 if (dumpAll) { 13545 pw.println(" mConfigWillChange: " + getFocusedStack().mConfigWillChange); 13546 if (mCompatModePackages.getPackages().size() > 0) { 13547 boolean printed = false; 13548 for (Map.Entry<String, Integer> entry 13549 : mCompatModePackages.getPackages().entrySet()) { 13550 String pkg = entry.getKey(); 13551 int mode = entry.getValue(); 13552 if (dumpPackage != null && !dumpPackage.equals(pkg)) { 13553 continue; 13554 } 13555 if (!printed) { 13556 pw.println(" mScreenCompatPackages:"); 13557 printed = true; 13558 } 13559 pw.print(" "); pw.print(pkg); pw.print(": "); 13560 pw.print(mode); pw.println(); 13561 } 13562 } 13563 } 13564 if (dumpPackage == null) { 13565 pw.println(" mWakefulness=" 13566 + PowerManagerInternal.wakefulnessToString(mWakefulness)); 13567 pw.println(" mSleepTokens=" + mSleepTokens); 13568 pw.println(" mSleeping=" + mSleeping + " mLockScreenShown=" 13569 + lockScreenShownToString()); 13570 pw.println(" mShuttingDown=" + mShuttingDown + " mTestPssMode=" + mTestPssMode); 13571 if (mRunningVoice != null) { 13572 pw.println(" mRunningVoice=" + mRunningVoice); 13573 pw.println(" mVoiceWakeLock" + mVoiceWakeLock); 13574 } 13575 } 13576 if (mDebugApp != null || mOrigDebugApp != null || mDebugTransient 13577 || mOrigWaitForDebugger) { 13578 if (dumpPackage == null || dumpPackage.equals(mDebugApp) 13579 || dumpPackage.equals(mOrigDebugApp)) { 13580 if (needSep) { 13581 pw.println(); 13582 needSep = false; 13583 } 13584 pw.println(" mDebugApp=" + mDebugApp + "/orig=" + mOrigDebugApp 13585 + " mDebugTransient=" + mDebugTransient 13586 + " mOrigWaitForDebugger=" + mOrigWaitForDebugger); 13587 } 13588 } 13589 if (mCurAppTimeTracker != null) { 13590 mCurAppTimeTracker.dumpWithHeader(pw, " ", true); 13591 } 13592 if (mMemWatchProcesses.getMap().size() > 0) { 13593 pw.println(" Mem watch processes:"); 13594 final ArrayMap<String, SparseArray<Pair<Long, String>>> procs 13595 = mMemWatchProcesses.getMap(); 13596 for (int i=0; i<procs.size(); i++) { 13597 final String proc = procs.keyAt(i); 13598 final SparseArray<Pair<Long, String>> uids = procs.valueAt(i); 13599 for (int j=0; j<uids.size(); j++) { 13600 if (needSep) { 13601 pw.println(); 13602 needSep = false; 13603 } 13604 StringBuilder sb = new StringBuilder(); 13605 sb.append(" ").append(proc).append('/'); 13606 UserHandle.formatUid(sb, uids.keyAt(j)); 13607 Pair<Long, String> val = uids.valueAt(j); 13608 sb.append(": "); DebugUtils.sizeValueToString(val.first, sb); 13609 if (val.second != null) { 13610 sb.append(", report to ").append(val.second); 13611 } 13612 pw.println(sb.toString()); 13613 } 13614 } 13615 pw.print(" mMemWatchDumpProcName="); pw.println(mMemWatchDumpProcName); 13616 pw.print(" mMemWatchDumpFile="); pw.println(mMemWatchDumpFile); 13617 pw.print(" mMemWatchDumpPid="); pw.print(mMemWatchDumpPid); 13618 pw.print(" mMemWatchDumpUid="); pw.println(mMemWatchDumpUid); 13619 } 13620 if (mOpenGlTraceApp != null) { 13621 if (dumpPackage == null || dumpPackage.equals(mOpenGlTraceApp)) { 13622 if (needSep) { 13623 pw.println(); 13624 needSep = false; 13625 } 13626 pw.println(" mOpenGlTraceApp=" + mOpenGlTraceApp); 13627 } 13628 } 13629 if (mTrackAllocationApp != null) { 13630 if (dumpPackage == null || dumpPackage.equals(mTrackAllocationApp)) { 13631 if (needSep) { 13632 pw.println(); 13633 needSep = false; 13634 } 13635 pw.println(" mTrackAllocationApp=" + mTrackAllocationApp); 13636 } 13637 } 13638 if (mProfileApp != null || mProfileProc != null || mProfileFile != null 13639 || mProfileFd != null) { 13640 if (dumpPackage == null || dumpPackage.equals(mProfileApp)) { 13641 if (needSep) { 13642 pw.println(); 13643 needSep = false; 13644 } 13645 pw.println(" mProfileApp=" + mProfileApp + " mProfileProc=" + mProfileProc); 13646 pw.println(" mProfileFile=" + mProfileFile + " mProfileFd=" + mProfileFd); 13647 pw.println(" mSamplingInterval=" + mSamplingInterval + " mAutoStopProfiler=" 13648 + mAutoStopProfiler); 13649 pw.println(" mProfileType=" + mProfileType); 13650 } 13651 } 13652 if (dumpPackage == null) { 13653 if (mAlwaysFinishActivities || mController != null) { 13654 pw.println(" mAlwaysFinishActivities=" + mAlwaysFinishActivities 13655 + " mController=" + mController); 13656 } 13657 if (dumpAll) { 13658 pw.println(" Total persistent processes: " + numPers); 13659 pw.println(" mProcessesReady=" + mProcessesReady 13660 + " mSystemReady=" + mSystemReady 13661 + " mBooted=" + mBooted 13662 + " mFactoryTest=" + mFactoryTest); 13663 pw.println(" mBooting=" + mBooting 13664 + " mCallFinishBooting=" + mCallFinishBooting 13665 + " mBootAnimationComplete=" + mBootAnimationComplete); 13666 pw.print(" mLastPowerCheckRealtime="); 13667 TimeUtils.formatDuration(mLastPowerCheckRealtime, pw); 13668 pw.println(""); 13669 pw.print(" mLastPowerCheckUptime="); 13670 TimeUtils.formatDuration(mLastPowerCheckUptime, pw); 13671 pw.println(""); 13672 pw.println(" mGoingToSleep=" + mStackSupervisor.mGoingToSleep); 13673 pw.println(" mLaunchingActivity=" + mStackSupervisor.mLaunchingActivity); 13674 pw.println(" mAdjSeq=" + mAdjSeq + " mLruSeq=" + mLruSeq); 13675 pw.println(" mNumNonCachedProcs=" + mNumNonCachedProcs 13676 + " (" + mLruProcesses.size() + " total)" 13677 + " mNumCachedHiddenProcs=" + mNumCachedHiddenProcs 13678 + " mNumServiceProcs=" + mNumServiceProcs 13679 + " mNewNumServiceProcs=" + mNewNumServiceProcs); 13680 pw.println(" mAllowLowerMemLevel=" + mAllowLowerMemLevel 13681 + " mLastMemoryLevel" + mLastMemoryLevel 13682 + " mLastNumProcesses" + mLastNumProcesses); 13683 long now = SystemClock.uptimeMillis(); 13684 pw.print(" mLastIdleTime="); 13685 TimeUtils.formatDuration(now, mLastIdleTime, pw); 13686 pw.print(" mLowRamSinceLastIdle="); 13687 TimeUtils.formatDuration(getLowRamTimeSinceIdle(now), pw); 13688 pw.println(); 13689 } 13690 } 13691 13692 if (!printedAnything) { 13693 pw.println(" (nothing)"); 13694 } 13695 } 13696 13697 boolean dumpProcessesToGc(FileDescriptor fd, PrintWriter pw, String[] args, 13698 int opti, boolean needSep, boolean dumpAll, String dumpPackage) { 13699 if (mProcessesToGc.size() > 0) { 13700 boolean printed = false; 13701 long now = SystemClock.uptimeMillis(); 13702 for (int i=0; i<mProcessesToGc.size(); i++) { 13703 ProcessRecord proc = mProcessesToGc.get(i); 13704 if (dumpPackage != null && !dumpPackage.equals(proc.info.packageName)) { 13705 continue; 13706 } 13707 if (!printed) { 13708 if (needSep) pw.println(); 13709 needSep = true; 13710 pw.println(" Processes that are waiting to GC:"); 13711 printed = true; 13712 } 13713 pw.print(" Process "); pw.println(proc); 13714 pw.print(" lowMem="); pw.print(proc.reportLowMemory); 13715 pw.print(", last gced="); 13716 pw.print(now-proc.lastRequestedGc); 13717 pw.print(" ms ago, last lowMem="); 13718 pw.print(now-proc.lastLowMemory); 13719 pw.println(" ms ago"); 13720 13721 } 13722 } 13723 return needSep; 13724 } 13725 13726 void printOomLevel(PrintWriter pw, String name, int adj) { 13727 pw.print(" "); 13728 if (adj >= 0) { 13729 pw.print(' '); 13730 if (adj < 10) pw.print(' '); 13731 } else { 13732 if (adj > -10) pw.print(' '); 13733 } 13734 pw.print(adj); 13735 pw.print(": "); 13736 pw.print(name); 13737 pw.print(" ("); 13738 pw.print(mProcessList.getMemLevel(adj)/1024); 13739 pw.println(" kB)"); 13740 } 13741 13742 boolean dumpOomLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13743 int opti, boolean dumpAll) { 13744 boolean needSep = false; 13745 13746 if (mLruProcesses.size() > 0) { 13747 if (needSep) pw.println(); 13748 needSep = true; 13749 pw.println(" OOM levels:"); 13750 printOomLevel(pw, "SYSTEM_ADJ", ProcessList.SYSTEM_ADJ); 13751 printOomLevel(pw, "PERSISTENT_PROC_ADJ", ProcessList.PERSISTENT_PROC_ADJ); 13752 printOomLevel(pw, "PERSISTENT_SERVICE_ADJ", ProcessList.PERSISTENT_SERVICE_ADJ); 13753 printOomLevel(pw, "FOREGROUND_APP_ADJ", ProcessList.FOREGROUND_APP_ADJ); 13754 printOomLevel(pw, "VISIBLE_APP_ADJ", ProcessList.VISIBLE_APP_ADJ); 13755 printOomLevel(pw, "PERCEPTIBLE_APP_ADJ", ProcessList.PERCEPTIBLE_APP_ADJ); 13756 printOomLevel(pw, "BACKUP_APP_ADJ", ProcessList.BACKUP_APP_ADJ); 13757 printOomLevel(pw, "HEAVY_WEIGHT_APP_ADJ", ProcessList.HEAVY_WEIGHT_APP_ADJ); 13758 printOomLevel(pw, "SERVICE_ADJ", ProcessList.SERVICE_ADJ); 13759 printOomLevel(pw, "HOME_APP_ADJ", ProcessList.HOME_APP_ADJ); 13760 printOomLevel(pw, "PREVIOUS_APP_ADJ", ProcessList.PREVIOUS_APP_ADJ); 13761 printOomLevel(pw, "SERVICE_B_ADJ", ProcessList.SERVICE_B_ADJ); 13762 printOomLevel(pw, "CACHED_APP_MIN_ADJ", ProcessList.CACHED_APP_MIN_ADJ); 13763 printOomLevel(pw, "CACHED_APP_MAX_ADJ", ProcessList.CACHED_APP_MAX_ADJ); 13764 13765 if (needSep) pw.println(); 13766 pw.print(" Process OOM control ("); pw.print(mLruProcesses.size()); 13767 pw.print(" total, non-act at "); 13768 pw.print(mLruProcesses.size()-mLruProcessActivityStart); 13769 pw.print(", non-svc at "); 13770 pw.print(mLruProcesses.size()-mLruProcessServiceStart); 13771 pw.println("):"); 13772 dumpProcessOomList(pw, this, mLruProcesses, " ", "Proc", "PERS", true, null); 13773 needSep = true; 13774 } 13775 13776 dumpProcessesToGc(fd, pw, args, opti, needSep, dumpAll, null); 13777 13778 pw.println(); 13779 pw.println(" mHomeProcess: " + mHomeProcess); 13780 pw.println(" mPreviousProcess: " + mPreviousProcess); 13781 if (mHeavyWeightProcess != null) { 13782 pw.println(" mHeavyWeightProcess: " + mHeavyWeightProcess); 13783 } 13784 13785 return true; 13786 } 13787 13788 /** 13789 * There are three ways to call this: 13790 * - no provider specified: dump all the providers 13791 * - a flattened component name that matched an existing provider was specified as the 13792 * first arg: dump that one provider 13793 * - the first arg isn't the flattened component name of an existing provider: 13794 * dump all providers whose component contains the first arg as a substring 13795 */ 13796 protected boolean dumpProvider(FileDescriptor fd, PrintWriter pw, String name, String[] args, 13797 int opti, boolean dumpAll) { 13798 return mProviderMap.dumpProvider(fd, pw, name, args, opti, dumpAll); 13799 } 13800 13801 static class ItemMatcher { 13802 ArrayList<ComponentName> components; 13803 ArrayList<String> strings; 13804 ArrayList<Integer> objects; 13805 boolean all; 13806 13807 ItemMatcher() { 13808 all = true; 13809 } 13810 13811 void build(String name) { 13812 ComponentName componentName = ComponentName.unflattenFromString(name); 13813 if (componentName != null) { 13814 if (components == null) { 13815 components = new ArrayList<ComponentName>(); 13816 } 13817 components.add(componentName); 13818 all = false; 13819 } else { 13820 int objectId = 0; 13821 // Not a '/' separated full component name; maybe an object ID? 13822 try { 13823 objectId = Integer.parseInt(name, 16); 13824 if (objects == null) { 13825 objects = new ArrayList<Integer>(); 13826 } 13827 objects.add(objectId); 13828 all = false; 13829 } catch (RuntimeException e) { 13830 // Not an integer; just do string match. 13831 if (strings == null) { 13832 strings = new ArrayList<String>(); 13833 } 13834 strings.add(name); 13835 all = false; 13836 } 13837 } 13838 } 13839 13840 int build(String[] args, int opti) { 13841 for (; opti<args.length; opti++) { 13842 String name = args[opti]; 13843 if ("--".equals(name)) { 13844 return opti+1; 13845 } 13846 build(name); 13847 } 13848 return opti; 13849 } 13850 13851 boolean match(Object object, ComponentName comp) { 13852 if (all) { 13853 return true; 13854 } 13855 if (components != null) { 13856 for (int i=0; i<components.size(); i++) { 13857 if (components.get(i).equals(comp)) { 13858 return true; 13859 } 13860 } 13861 } 13862 if (objects != null) { 13863 for (int i=0; i<objects.size(); i++) { 13864 if (System.identityHashCode(object) == objects.get(i)) { 13865 return true; 13866 } 13867 } 13868 } 13869 if (strings != null) { 13870 String flat = comp.flattenToString(); 13871 for (int i=0; i<strings.size(); i++) { 13872 if (flat.contains(strings.get(i))) { 13873 return true; 13874 } 13875 } 13876 } 13877 return false; 13878 } 13879 } 13880 13881 /** 13882 * There are three things that cmd can be: 13883 * - a flattened component name that matches an existing activity 13884 * - the cmd arg isn't the flattened component name of an existing activity: 13885 * dump all activity whose component contains the cmd as a substring 13886 * - A hex number of the ActivityRecord object instance. 13887 */ 13888 protected boolean dumpActivity(FileDescriptor fd, PrintWriter pw, String name, String[] args, 13889 int opti, boolean dumpAll) { 13890 ArrayList<ActivityRecord> activities; 13891 13892 synchronized (this) { 13893 activities = mStackSupervisor.getDumpActivitiesLocked(name); 13894 } 13895 13896 if (activities.size() <= 0) { 13897 return false; 13898 } 13899 13900 String[] newArgs = new String[args.length - opti]; 13901 System.arraycopy(args, opti, newArgs, 0, args.length - opti); 13902 13903 TaskRecord lastTask = null; 13904 boolean needSep = false; 13905 for (int i=activities.size()-1; i>=0; i--) { 13906 ActivityRecord r = activities.get(i); 13907 if (needSep) { 13908 pw.println(); 13909 } 13910 needSep = true; 13911 synchronized (this) { 13912 if (lastTask != r.task) { 13913 lastTask = r.task; 13914 pw.print("TASK "); pw.print(lastTask.affinity); 13915 pw.print(" id="); pw.println(lastTask.taskId); 13916 if (dumpAll) { 13917 lastTask.dump(pw, " "); 13918 } 13919 } 13920 } 13921 dumpActivity(" ", fd, pw, activities.get(i), newArgs, dumpAll); 13922 } 13923 return true; 13924 } 13925 13926 /** 13927 * Invokes IApplicationThread.dumpActivity() on the thread of the specified activity if 13928 * there is a thread associated with the activity. 13929 */ 13930 private void dumpActivity(String prefix, FileDescriptor fd, PrintWriter pw, 13931 final ActivityRecord r, String[] args, boolean dumpAll) { 13932 String innerPrefix = prefix + " "; 13933 synchronized (this) { 13934 pw.print(prefix); pw.print("ACTIVITY "); pw.print(r.shortComponentName); 13935 pw.print(" "); pw.print(Integer.toHexString(System.identityHashCode(r))); 13936 pw.print(" pid="); 13937 if (r.app != null) pw.println(r.app.pid); 13938 else pw.println("(not running)"); 13939 if (dumpAll) { 13940 r.dump(pw, innerPrefix); 13941 } 13942 } 13943 if (r.app != null && r.app.thread != null) { 13944 // flush anything that is already in the PrintWriter since the thread is going 13945 // to write to the file descriptor directly 13946 pw.flush(); 13947 try { 13948 TransferPipe tp = new TransferPipe(); 13949 try { 13950 r.app.thread.dumpActivity(tp.getWriteFd().getFileDescriptor(), 13951 r.appToken, innerPrefix, args); 13952 tp.go(fd); 13953 } finally { 13954 tp.kill(); 13955 } 13956 } catch (IOException e) { 13957 pw.println(innerPrefix + "Failure while dumping the activity: " + e); 13958 } catch (RemoteException e) { 13959 pw.println(innerPrefix + "Got a RemoteException while dumping the activity"); 13960 } 13961 } 13962 } 13963 13964 void dumpBroadcastsLocked(FileDescriptor fd, PrintWriter pw, String[] args, 13965 int opti, boolean dumpAll, String dumpPackage) { 13966 boolean needSep = false; 13967 boolean onlyHistory = false; 13968 boolean printedAnything = false; 13969 13970 if ("history".equals(dumpPackage)) { 13971 if (opti < args.length && "-s".equals(args[opti])) { 13972 dumpAll = false; 13973 } 13974 onlyHistory = true; 13975 dumpPackage = null; 13976 } 13977 13978 pw.println("ACTIVITY MANAGER BROADCAST STATE (dumpsys activity broadcasts)"); 13979 if (!onlyHistory && dumpAll) { 13980 if (mRegisteredReceivers.size() > 0) { 13981 boolean printed = false; 13982 Iterator it = mRegisteredReceivers.values().iterator(); 13983 while (it.hasNext()) { 13984 ReceiverList r = (ReceiverList)it.next(); 13985 if (dumpPackage != null && (r.app == null || 13986 !dumpPackage.equals(r.app.info.packageName))) { 13987 continue; 13988 } 13989 if (!printed) { 13990 pw.println(" Registered Receivers:"); 13991 needSep = true; 13992 printed = true; 13993 printedAnything = true; 13994 } 13995 pw.print(" * "); pw.println(r); 13996 r.dump(pw, " "); 13997 } 13998 } 13999 14000 if (mReceiverResolver.dump(pw, needSep ? 14001 "\n Receiver Resolver Table:" : " Receiver Resolver Table:", 14002 " ", dumpPackage, false, false)) { 14003 needSep = true; 14004 printedAnything = true; 14005 } 14006 } 14007 14008 for (BroadcastQueue q : mBroadcastQueues) { 14009 needSep = q.dumpLocked(fd, pw, args, opti, dumpAll, dumpPackage, needSep); 14010 printedAnything |= needSep; 14011 } 14012 14013 needSep = true; 14014 14015 if (!onlyHistory && mStickyBroadcasts != null && dumpPackage == null) { 14016 for (int user=0; user<mStickyBroadcasts.size(); user++) { 14017 if (needSep) { 14018 pw.println(); 14019 } 14020 needSep = true; 14021 printedAnything = true; 14022 pw.print(" Sticky broadcasts for user "); 14023 pw.print(mStickyBroadcasts.keyAt(user)); pw.println(":"); 14024 StringBuilder sb = new StringBuilder(128); 14025 for (Map.Entry<String, ArrayList<Intent>> ent 14026 : mStickyBroadcasts.valueAt(user).entrySet()) { 14027 pw.print(" * Sticky action "); pw.print(ent.getKey()); 14028 if (dumpAll) { 14029 pw.println(":"); 14030 ArrayList<Intent> intents = ent.getValue(); 14031 final int N = intents.size(); 14032 for (int i=0; i<N; i++) { 14033 sb.setLength(0); 14034 sb.append(" Intent: "); 14035 intents.get(i).toShortString(sb, false, true, false, false); 14036 pw.println(sb.toString()); 14037 Bundle bundle = intents.get(i).getExtras(); 14038 if (bundle != null) { 14039 pw.print(" "); 14040 pw.println(bundle.toString()); 14041 } 14042 } 14043 } else { 14044 pw.println(""); 14045 } 14046 } 14047 } 14048 } 14049 14050 if (!onlyHistory && dumpAll) { 14051 pw.println(); 14052 for (BroadcastQueue queue : mBroadcastQueues) { 14053 pw.println(" mBroadcastsScheduled [" + queue.mQueueName + "]=" 14054 + queue.mBroadcastsScheduled); 14055 } 14056 pw.println(" mHandler:"); 14057 mHandler.dump(new PrintWriterPrinter(pw), " "); 14058 needSep = true; 14059 printedAnything = true; 14060 } 14061 14062 if (!printedAnything) { 14063 pw.println(" (nothing)"); 14064 } 14065 } 14066 14067 void dumpProvidersLocked(FileDescriptor fd, PrintWriter pw, String[] args, 14068 int opti, boolean dumpAll, String dumpPackage) { 14069 boolean needSep; 14070 boolean printedAnything = false; 14071 14072 ItemMatcher matcher = new ItemMatcher(); 14073 matcher.build(args, opti); 14074 14075 pw.println("ACTIVITY MANAGER CONTENT PROVIDERS (dumpsys activity providers)"); 14076 14077 needSep = mProviderMap.dumpProvidersLocked(pw, dumpAll, dumpPackage); 14078 printedAnything |= needSep; 14079 14080 if (mLaunchingProviders.size() > 0) { 14081 boolean printed = false; 14082 for (int i=mLaunchingProviders.size()-1; i>=0; i--) { 14083 ContentProviderRecord r = mLaunchingProviders.get(i); 14084 if (dumpPackage != null && !dumpPackage.equals(r.name.getPackageName())) { 14085 continue; 14086 } 14087 if (!printed) { 14088 if (needSep) pw.println(); 14089 needSep = true; 14090 pw.println(" Launching content providers:"); 14091 printed = true; 14092 printedAnything = true; 14093 } 14094 pw.print(" Launching #"); pw.print(i); pw.print(": "); 14095 pw.println(r); 14096 } 14097 } 14098 14099 if (!printedAnything) { 14100 pw.println(" (nothing)"); 14101 } 14102 } 14103 14104 void dumpPermissionsLocked(FileDescriptor fd, PrintWriter pw, String[] args, 14105 int opti, boolean dumpAll, String dumpPackage) { 14106 boolean needSep = false; 14107 boolean printedAnything = false; 14108 14109 pw.println("ACTIVITY MANAGER URI PERMISSIONS (dumpsys activity permissions)"); 14110 14111 if (mGrantedUriPermissions.size() > 0) { 14112 boolean printed = false; 14113 int dumpUid = -2; 14114 if (dumpPackage != null) { 14115 try { 14116 dumpUid = mContext.getPackageManager().getPackageUid(dumpPackage, 0); 14117 } catch (NameNotFoundException e) { 14118 dumpUid = -1; 14119 } 14120 } 14121 for (int i=0; i<mGrantedUriPermissions.size(); i++) { 14122 int uid = mGrantedUriPermissions.keyAt(i); 14123 if (dumpUid >= -1 && UserHandle.getAppId(uid) != dumpUid) { 14124 continue; 14125 } 14126 final ArrayMap<GrantUri, UriPermission> perms = mGrantedUriPermissions.valueAt(i); 14127 if (!printed) { 14128 if (needSep) pw.println(); 14129 needSep = true; 14130 pw.println(" Granted Uri Permissions:"); 14131 printed = true; 14132 printedAnything = true; 14133 } 14134 pw.print(" * UID "); pw.print(uid); pw.println(" holds:"); 14135 for (UriPermission perm : perms.values()) { 14136 pw.print(" "); pw.println(perm); 14137 if (dumpAll) { 14138 perm.dump(pw, " "); 14139 } 14140 } 14141 } 14142 } 14143 14144 if (!printedAnything) { 14145 pw.println(" (nothing)"); 14146 } 14147 } 14148 14149 void dumpPendingIntentsLocked(FileDescriptor fd, PrintWriter pw, String[] args, 14150 int opti, boolean dumpAll, String dumpPackage) { 14151 boolean printed = false; 14152 14153 pw.println("ACTIVITY MANAGER PENDING INTENTS (dumpsys activity intents)"); 14154 14155 if (mIntentSenderRecords.size() > 0) { 14156 Iterator<WeakReference<PendingIntentRecord>> it 14157 = mIntentSenderRecords.values().iterator(); 14158 while (it.hasNext()) { 14159 WeakReference<PendingIntentRecord> ref = it.next(); 14160 PendingIntentRecord rec = ref != null ? ref.get(): null; 14161 if (dumpPackage != null && (rec == null 14162 || !dumpPackage.equals(rec.key.packageName))) { 14163 continue; 14164 } 14165 printed = true; 14166 if (rec != null) { 14167 pw.print(" * "); pw.println(rec); 14168 if (dumpAll) { 14169 rec.dump(pw, " "); 14170 } 14171 } else { 14172 pw.print(" * "); pw.println(ref); 14173 } 14174 } 14175 } 14176 14177 if (!printed) { 14178 pw.println(" (nothing)"); 14179 } 14180 } 14181 14182 private static final int dumpProcessList(PrintWriter pw, 14183 ActivityManagerService service, List list, 14184 String prefix, String normalLabel, String persistentLabel, 14185 String dumpPackage) { 14186 int numPers = 0; 14187 final int N = list.size()-1; 14188 for (int i=N; i>=0; i--) { 14189 ProcessRecord r = (ProcessRecord)list.get(i); 14190 if (dumpPackage != null && !dumpPackage.equals(r.info.packageName)) { 14191 continue; 14192 } 14193 pw.println(String.format("%s%s #%2d: %s", 14194 prefix, (r.persistent ? persistentLabel : normalLabel), 14195 i, r.toString())); 14196 if (r.persistent) { 14197 numPers++; 14198 } 14199 } 14200 return numPers; 14201 } 14202 14203 private static final boolean dumpProcessOomList(PrintWriter pw, 14204 ActivityManagerService service, List<ProcessRecord> origList, 14205 String prefix, String normalLabel, String persistentLabel, 14206 boolean inclDetails, String dumpPackage) { 14207 14208 ArrayList<Pair<ProcessRecord, Integer>> list 14209 = new ArrayList<Pair<ProcessRecord, Integer>>(origList.size()); 14210 for (int i=0; i<origList.size(); i++) { 14211 ProcessRecord r = origList.get(i); 14212 if (dumpPackage != null && !r.pkgList.containsKey(dumpPackage)) { 14213 continue; 14214 } 14215 list.add(new Pair<ProcessRecord, Integer>(origList.get(i), i)); 14216 } 14217 14218 if (list.size() <= 0) { 14219 return false; 14220 } 14221 14222 Comparator<Pair<ProcessRecord, Integer>> comparator 14223 = new Comparator<Pair<ProcessRecord, Integer>>() { 14224 @Override 14225 public int compare(Pair<ProcessRecord, Integer> object1, 14226 Pair<ProcessRecord, Integer> object2) { 14227 if (object1.first.setAdj != object2.first.setAdj) { 14228 return object1.first.setAdj > object2.first.setAdj ? -1 : 1; 14229 } 14230 if (object1.second.intValue() != object2.second.intValue()) { 14231 return object1.second.intValue() > object2.second.intValue() ? -1 : 1; 14232 } 14233 return 0; 14234 } 14235 }; 14236 14237 Collections.sort(list, comparator); 14238 14239 final long curRealtime = SystemClock.elapsedRealtime(); 14240 final long realtimeSince = curRealtime - service.mLastPowerCheckRealtime; 14241 final long curUptime = SystemClock.uptimeMillis(); 14242 final long uptimeSince = curUptime - service.mLastPowerCheckUptime; 14243 14244 for (int i=list.size()-1; i>=0; i--) { 14245 ProcessRecord r = list.get(i).first; 14246 String oomAdj = ProcessList.makeOomAdjString(r.setAdj); 14247 char schedGroup; 14248 switch (r.setSchedGroup) { 14249 case Process.THREAD_GROUP_BG_NONINTERACTIVE: 14250 schedGroup = 'B'; 14251 break; 14252 case Process.THREAD_GROUP_DEFAULT: 14253 schedGroup = 'F'; 14254 break; 14255 default: 14256 schedGroup = '?'; 14257 break; 14258 } 14259 char foreground; 14260 if (r.foregroundActivities) { 14261 foreground = 'A'; 14262 } else if (r.foregroundServices) { 14263 foreground = 'S'; 14264 } else { 14265 foreground = ' '; 14266 } 14267 String procState = ProcessList.makeProcStateString(r.curProcState); 14268 pw.print(prefix); 14269 pw.print(r.persistent ? persistentLabel : normalLabel); 14270 pw.print(" #"); 14271 int num = (origList.size()-1)-list.get(i).second; 14272 if (num < 10) pw.print(' '); 14273 pw.print(num); 14274 pw.print(": "); 14275 pw.print(oomAdj); 14276 pw.print(' '); 14277 pw.print(schedGroup); 14278 pw.print('/'); 14279 pw.print(foreground); 14280 pw.print('/'); 14281 pw.print(procState); 14282 pw.print(" trm:"); 14283 if (r.trimMemoryLevel < 10) pw.print(' '); 14284 pw.print(r.trimMemoryLevel); 14285 pw.print(' '); 14286 pw.print(r.toShortString()); 14287 pw.print(" ("); 14288 pw.print(r.adjType); 14289 pw.println(')'); 14290 if (r.adjSource != null || r.adjTarget != null) { 14291 pw.print(prefix); 14292 pw.print(" "); 14293 if (r.adjTarget instanceof ComponentName) { 14294 pw.print(((ComponentName)r.adjTarget).flattenToShortString()); 14295 } else if (r.adjTarget != null) { 14296 pw.print(r.adjTarget.toString()); 14297 } else { 14298 pw.print("{null}"); 14299 } 14300 pw.print("<="); 14301 if (r.adjSource instanceof ProcessRecord) { 14302 pw.print("Proc{"); 14303 pw.print(((ProcessRecord)r.adjSource).toShortString()); 14304 pw.println("}"); 14305 } else if (r.adjSource != null) { 14306 pw.println(r.adjSource.toString()); 14307 } else { 14308 pw.println("{null}"); 14309 } 14310 } 14311 if (inclDetails) { 14312 pw.print(prefix); 14313 pw.print(" "); 14314 pw.print("oom: max="); pw.print(r.maxAdj); 14315 pw.print(" curRaw="); pw.print(r.curRawAdj); 14316 pw.print(" setRaw="); pw.print(r.setRawAdj); 14317 pw.print(" cur="); pw.print(r.curAdj); 14318 pw.print(" set="); pw.println(r.setAdj); 14319 pw.print(prefix); 14320 pw.print(" "); 14321 pw.print("state: cur="); pw.print(ProcessList.makeProcStateString(r.curProcState)); 14322 pw.print(" set="); pw.print(ProcessList.makeProcStateString(r.setProcState)); 14323 pw.print(" lastPss="); DebugUtils.printSizeValue(pw, r.lastPss*1024); 14324 pw.print(" lastCachedPss="); DebugUtils.printSizeValue(pw, r.lastCachedPss*1024); 14325 pw.println(); 14326 pw.print(prefix); 14327 pw.print(" "); 14328 pw.print("cached="); pw.print(r.cached); 14329 pw.print(" empty="); pw.print(r.empty); 14330 pw.print(" hasAboveClient="); pw.println(r.hasAboveClient); 14331 14332 if (r.setProcState >= ActivityManager.PROCESS_STATE_SERVICE) { 14333 if (r.lastWakeTime != 0) { 14334 long wtime; 14335 BatteryStatsImpl stats = service.mBatteryStatsService.getActiveStatistics(); 14336 synchronized (stats) { 14337 wtime = stats.getProcessWakeTime(r.info.uid, 14338 r.pid, curRealtime); 14339 } 14340 long timeUsed = wtime - r.lastWakeTime; 14341 pw.print(prefix); 14342 pw.print(" "); 14343 pw.print("keep awake over "); 14344 TimeUtils.formatDuration(realtimeSince, pw); 14345 pw.print(" used "); 14346 TimeUtils.formatDuration(timeUsed, pw); 14347 pw.print(" ("); 14348 pw.print((timeUsed*100)/realtimeSince); 14349 pw.println("%)"); 14350 } 14351 if (r.lastCpuTime != 0) { 14352 long timeUsed = r.curCpuTime - r.lastCpuTime; 14353 pw.print(prefix); 14354 pw.print(" "); 14355 pw.print("run cpu over "); 14356 TimeUtils.formatDuration(uptimeSince, pw); 14357 pw.print(" used "); 14358 TimeUtils.formatDuration(timeUsed, pw); 14359 pw.print(" ("); 14360 pw.print((timeUsed*100)/uptimeSince); 14361 pw.println("%)"); 14362 } 14363 } 14364 } 14365 } 14366 return true; 14367 } 14368 14369 ArrayList<ProcessRecord> collectProcesses(PrintWriter pw, int start, boolean allPkgs, 14370 String[] args) { 14371 ArrayList<ProcessRecord> procs; 14372 synchronized (this) { 14373 if (args != null && args.length > start 14374 && args[start].charAt(0) != '-') { 14375 procs = new ArrayList<ProcessRecord>(); 14376 int pid = -1; 14377 try { 14378 pid = Integer.parseInt(args[start]); 14379 } catch (NumberFormatException e) { 14380 } 14381 for (int i=mLruProcesses.size()-1; i>=0; i--) { 14382 ProcessRecord proc = mLruProcesses.get(i); 14383 if (proc.pid == pid) { 14384 procs.add(proc); 14385 } else if (allPkgs && proc.pkgList != null 14386 && proc.pkgList.containsKey(args[start])) { 14387 procs.add(proc); 14388 } else if (proc.processName.equals(args[start])) { 14389 procs.add(proc); 14390 } 14391 } 14392 if (procs.size() <= 0) { 14393 return null; 14394 } 14395 } else { 14396 procs = new ArrayList<ProcessRecord>(mLruProcesses); 14397 } 14398 } 14399 return procs; 14400 } 14401 14402 final void dumpGraphicsHardwareUsage(FileDescriptor fd, 14403 PrintWriter pw, String[] args) { 14404 ArrayList<ProcessRecord> procs = collectProcesses(pw, 0, false, args); 14405 if (procs == null) { 14406 pw.println("No process found for: " + args[0]); 14407 return; 14408 } 14409 14410 long uptime = SystemClock.uptimeMillis(); 14411 long realtime = SystemClock.elapsedRealtime(); 14412 pw.println("Applications Graphics Acceleration Info:"); 14413 pw.println("Uptime: " + uptime + " Realtime: " + realtime); 14414 14415 for (int i = procs.size() - 1 ; i >= 0 ; i--) { 14416 ProcessRecord r = procs.get(i); 14417 if (r.thread != null) { 14418 pw.println("\n** Graphics info for pid " + r.pid + " [" + r.processName + "] **"); 14419 pw.flush(); 14420 try { 14421 TransferPipe tp = new TransferPipe(); 14422 try { 14423 r.thread.dumpGfxInfo(tp.getWriteFd().getFileDescriptor(), args); 14424 tp.go(fd); 14425 } finally { 14426 tp.kill(); 14427 } 14428 } catch (IOException e) { 14429 pw.println("Failure while dumping the app: " + r); 14430 pw.flush(); 14431 } catch (RemoteException e) { 14432 pw.println("Got a RemoteException while dumping the app " + r); 14433 pw.flush(); 14434 } 14435 } 14436 } 14437 } 14438 14439 final void dumpDbInfo(FileDescriptor fd, PrintWriter pw, String[] args) { 14440 ArrayList<ProcessRecord> procs = collectProcesses(pw, 0, false, args); 14441 if (procs == null) { 14442 pw.println("No process found for: " + args[0]); 14443 return; 14444 } 14445 14446 pw.println("Applications Database Info:"); 14447 14448 for (int i = procs.size() - 1 ; i >= 0 ; i--) { 14449 ProcessRecord r = procs.get(i); 14450 if (r.thread != null) { 14451 pw.println("\n** Database info for pid " + r.pid + " [" + r.processName + "] **"); 14452 pw.flush(); 14453 try { 14454 TransferPipe tp = new TransferPipe(); 14455 try { 14456 r.thread.dumpDbInfo(tp.getWriteFd().getFileDescriptor(), args); 14457 tp.go(fd); 14458 } finally { 14459 tp.kill(); 14460 } 14461 } catch (IOException e) { 14462 pw.println("Failure while dumping the app: " + r); 14463 pw.flush(); 14464 } catch (RemoteException e) { 14465 pw.println("Got a RemoteException while dumping the app " + r); 14466 pw.flush(); 14467 } 14468 } 14469 } 14470 } 14471 14472 final static class MemItem { 14473 final boolean isProc; 14474 final String label; 14475 final String shortLabel; 14476 final long pss; 14477 final int id; 14478 final boolean hasActivities; 14479 ArrayList<MemItem> subitems; 14480 14481 public MemItem(String _label, String _shortLabel, long _pss, int _id, 14482 boolean _hasActivities) { 14483 isProc = true; 14484 label = _label; 14485 shortLabel = _shortLabel; 14486 pss = _pss; 14487 id = _id; 14488 hasActivities = _hasActivities; 14489 } 14490 14491 public MemItem(String _label, String _shortLabel, long _pss, int _id) { 14492 isProc = false; 14493 label = _label; 14494 shortLabel = _shortLabel; 14495 pss = _pss; 14496 id = _id; 14497 hasActivities = false; 14498 } 14499 } 14500 14501 static final void dumpMemItems(PrintWriter pw, String prefix, String tag, 14502 ArrayList<MemItem> items, boolean sort, boolean isCompact) { 14503 if (sort && !isCompact) { 14504 Collections.sort(items, new Comparator<MemItem>() { 14505 @Override 14506 public int compare(MemItem lhs, MemItem rhs) { 14507 if (lhs.pss < rhs.pss) { 14508 return 1; 14509 } else if (lhs.pss > rhs.pss) { 14510 return -1; 14511 } 14512 return 0; 14513 } 14514 }); 14515 } 14516 14517 for (int i=0; i<items.size(); i++) { 14518 MemItem mi = items.get(i); 14519 if (!isCompact) { 14520 pw.print(prefix); pw.printf("%7d kB: ", mi.pss); pw.println(mi.label); 14521 } else if (mi.isProc) { 14522 pw.print("proc,"); pw.print(tag); pw.print(","); pw.print(mi.shortLabel); 14523 pw.print(","); pw.print(mi.id); pw.print(","); pw.print(mi.pss); 14524 pw.println(mi.hasActivities ? ",a" : ",e"); 14525 } else { 14526 pw.print(tag); pw.print(","); pw.print(mi.shortLabel); pw.print(","); 14527 pw.println(mi.pss); 14528 } 14529 if (mi.subitems != null) { 14530 dumpMemItems(pw, prefix + " ", mi.shortLabel, mi.subitems, 14531 true, isCompact); 14532 } 14533 } 14534 } 14535 14536 // These are in KB. 14537 static final long[] DUMP_MEM_BUCKETS = new long[] { 14538 5*1024, 7*1024, 10*1024, 15*1024, 20*1024, 30*1024, 40*1024, 80*1024, 14539 120*1024, 160*1024, 200*1024, 14540 250*1024, 300*1024, 350*1024, 400*1024, 500*1024, 600*1024, 800*1024, 14541 1*1024*1024, 2*1024*1024, 5*1024*1024, 10*1024*1024, 20*1024*1024 14542 }; 14543 14544 static final void appendMemBucket(StringBuilder out, long memKB, String label, 14545 boolean stackLike) { 14546 int start = label.lastIndexOf('.'); 14547 if (start >= 0) start++; 14548 else start = 0; 14549 int end = label.length(); 14550 for (int i=0; i<DUMP_MEM_BUCKETS.length; i++) { 14551 if (DUMP_MEM_BUCKETS[i] >= memKB) { 14552 long bucket = DUMP_MEM_BUCKETS[i]/1024; 14553 out.append(bucket); 14554 out.append(stackLike ? "MB." : "MB "); 14555 out.append(label, start, end); 14556 return; 14557 } 14558 } 14559 out.append(memKB/1024); 14560 out.append(stackLike ? "MB." : "MB "); 14561 out.append(label, start, end); 14562 } 14563 14564 static final int[] DUMP_MEM_OOM_ADJ = new int[] { 14565 ProcessList.NATIVE_ADJ, 14566 ProcessList.SYSTEM_ADJ, ProcessList.PERSISTENT_PROC_ADJ, 14567 ProcessList.PERSISTENT_SERVICE_ADJ, ProcessList.FOREGROUND_APP_ADJ, 14568 ProcessList.VISIBLE_APP_ADJ, ProcessList.PERCEPTIBLE_APP_ADJ, 14569 ProcessList.BACKUP_APP_ADJ, ProcessList.HEAVY_WEIGHT_APP_ADJ, 14570 ProcessList.SERVICE_ADJ, ProcessList.HOME_APP_ADJ, 14571 ProcessList.PREVIOUS_APP_ADJ, ProcessList.SERVICE_B_ADJ, ProcessList.CACHED_APP_MAX_ADJ 14572 }; 14573 static final String[] DUMP_MEM_OOM_LABEL = new String[] { 14574 "Native", 14575 "System", "Persistent", "Persistent Service", "Foreground", 14576 "Visible", "Perceptible", 14577 "Heavy Weight", "Backup", 14578 "A Services", "Home", 14579 "Previous", "B Services", "Cached" 14580 }; 14581 static final String[] DUMP_MEM_OOM_COMPACT_LABEL = new String[] { 14582 "native", 14583 "sys", "pers", "persvc", "fore", 14584 "vis", "percept", 14585 "heavy", "backup", 14586 "servicea", "home", 14587 "prev", "serviceb", "cached" 14588 }; 14589 14590 private final void dumpApplicationMemoryUsageHeader(PrintWriter pw, long uptime, 14591 long realtime, boolean isCheckinRequest, boolean isCompact) { 14592 if (isCheckinRequest || isCompact) { 14593 // short checkin version 14594 pw.print("time,"); pw.print(uptime); pw.print(","); pw.println(realtime); 14595 } else { 14596 pw.println("Applications Memory Usage (kB):"); 14597 pw.println("Uptime: " + uptime + " Realtime: " + realtime); 14598 } 14599 } 14600 14601 private static final int KSM_SHARED = 0; 14602 private static final int KSM_SHARING = 1; 14603 private static final int KSM_UNSHARED = 2; 14604 private static final int KSM_VOLATILE = 3; 14605 14606 private final long[] getKsmInfo() { 14607 long[] longOut = new long[4]; 14608 final int[] SINGLE_LONG_FORMAT = new int[] { 14609 Process.PROC_SPACE_TERM|Process.PROC_OUT_LONG 14610 }; 14611 long[] longTmp = new long[1]; 14612 Process.readProcFile("/sys/kernel/mm/ksm/pages_shared", 14613 SINGLE_LONG_FORMAT, null, longTmp, null); 14614 longOut[KSM_SHARED] = longTmp[0] * ProcessList.PAGE_SIZE / 1024; 14615 longTmp[0] = 0; 14616 Process.readProcFile("/sys/kernel/mm/ksm/pages_sharing", 14617 SINGLE_LONG_FORMAT, null, longTmp, null); 14618 longOut[KSM_SHARING] = longTmp[0] * ProcessList.PAGE_SIZE / 1024; 14619 longTmp[0] = 0; 14620 Process.readProcFile("/sys/kernel/mm/ksm/pages_unshared", 14621 SINGLE_LONG_FORMAT, null, longTmp, null); 14622 longOut[KSM_UNSHARED] = longTmp[0] * ProcessList.PAGE_SIZE / 1024; 14623 longTmp[0] = 0; 14624 Process.readProcFile("/sys/kernel/mm/ksm/pages_volatile", 14625 SINGLE_LONG_FORMAT, null, longTmp, null); 14626 longOut[KSM_VOLATILE] = longTmp[0] * ProcessList.PAGE_SIZE / 1024; 14627 return longOut; 14628 } 14629 14630 final void dumpApplicationMemoryUsage(FileDescriptor fd, 14631 PrintWriter pw, String prefix, String[] args, boolean brief, PrintWriter categoryPw) { 14632 boolean dumpDetails = false; 14633 boolean dumpFullDetails = false; 14634 boolean dumpDalvik = false; 14635 boolean dumpSummaryOnly = false; 14636 boolean oomOnly = false; 14637 boolean isCompact = false; 14638 boolean localOnly = false; 14639 boolean packages = false; 14640 14641 int opti = 0; 14642 while (opti < args.length) { 14643 String opt = args[opti]; 14644 if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') { 14645 break; 14646 } 14647 opti++; 14648 if ("-a".equals(opt)) { 14649 dumpDetails = true; 14650 dumpFullDetails = true; 14651 dumpDalvik = true; 14652 } else if ("-d".equals(opt)) { 14653 dumpDalvik = true; 14654 } else if ("-c".equals(opt)) { 14655 isCompact = true; 14656 } else if ("-s".equals(opt)) { 14657 dumpDetails = true; 14658 dumpSummaryOnly = true; 14659 } else if ("--oom".equals(opt)) { 14660 oomOnly = true; 14661 } else if ("--local".equals(opt)) { 14662 localOnly = true; 14663 } else if ("--package".equals(opt)) { 14664 packages = true; 14665 } else if ("-h".equals(opt)) { 14666 pw.println("meminfo dump options: [-a] [-d] [-c] [-s] [--oom] [process]"); 14667 pw.println(" -a: include all available information for each process."); 14668 pw.println(" -d: include dalvik details."); 14669 pw.println(" -c: dump in a compact machine-parseable representation."); 14670 pw.println(" -s: dump only summary of application memory usage."); 14671 pw.println(" --oom: only show processes organized by oom adj."); 14672 pw.println(" --local: only collect details locally, don't call process."); 14673 pw.println(" --package: interpret process arg as package, dumping all"); 14674 pw.println(" processes that have loaded that package."); 14675 pw.println("If [process] is specified it can be the name or "); 14676 pw.println("pid of a specific process to dump."); 14677 return; 14678 } else { 14679 pw.println("Unknown argument: " + opt + "; use -h for help"); 14680 } 14681 } 14682 14683 final boolean isCheckinRequest = scanArgs(args, "--checkin"); 14684 long uptime = SystemClock.uptimeMillis(); 14685 long realtime = SystemClock.elapsedRealtime(); 14686 final long[] tmpLong = new long[1]; 14687 14688 ArrayList<ProcessRecord> procs = collectProcesses(pw, opti, packages, args); 14689 if (procs == null) { 14690 // No Java processes. Maybe they want to print a native process. 14691 if (args != null && args.length > opti 14692 && args[opti].charAt(0) != '-') { 14693 ArrayList<ProcessCpuTracker.Stats> nativeProcs 14694 = new ArrayList<ProcessCpuTracker.Stats>(); 14695 updateCpuStatsNow(); 14696 int findPid = -1; 14697 try { 14698 findPid = Integer.parseInt(args[opti]); 14699 } catch (NumberFormatException e) { 14700 } 14701 synchronized (mProcessCpuTracker) { 14702 final int N = mProcessCpuTracker.countStats(); 14703 for (int i=0; i<N; i++) { 14704 ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i); 14705 if (st.pid == findPid || (st.baseName != null 14706 && st.baseName.equals(args[opti]))) { 14707 nativeProcs.add(st); 14708 } 14709 } 14710 } 14711 if (nativeProcs.size() > 0) { 14712 dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, 14713 isCompact); 14714 Debug.MemoryInfo mi = null; 14715 for (int i = nativeProcs.size() - 1 ; i >= 0 ; i--) { 14716 final ProcessCpuTracker.Stats r = nativeProcs.get(i); 14717 final int pid = r.pid; 14718 if (!isCheckinRequest && dumpDetails) { 14719 pw.println("\n** MEMINFO in pid " + pid + " [" + r.baseName + "] **"); 14720 } 14721 if (mi == null) { 14722 mi = new Debug.MemoryInfo(); 14723 } 14724 if (dumpDetails || (!brief && !oomOnly)) { 14725 Debug.getMemoryInfo(pid, mi); 14726 } else { 14727 mi.dalvikPss = (int)Debug.getPss(pid, tmpLong, null); 14728 mi.dalvikPrivateDirty = (int)tmpLong[0]; 14729 } 14730 ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, 14731 dumpDalvik, dumpSummaryOnly, pid, r.baseName, 0, 0, 0, 0, 0, 0); 14732 if (isCheckinRequest) { 14733 pw.println(); 14734 } 14735 } 14736 return; 14737 } 14738 } 14739 pw.println("No process found for: " + args[opti]); 14740 return; 14741 } 14742 14743 if (!brief && !oomOnly && (procs.size() == 1 || isCheckinRequest || packages)) { 14744 dumpDetails = true; 14745 } 14746 14747 dumpApplicationMemoryUsageHeader(pw, uptime, realtime, isCheckinRequest, isCompact); 14748 14749 String[] innerArgs = new String[args.length-opti]; 14750 System.arraycopy(args, opti, innerArgs, 0, args.length-opti); 14751 14752 ArrayList<MemItem> procMems = new ArrayList<MemItem>(); 14753 final SparseArray<MemItem> procMemsMap = new SparseArray<MemItem>(); 14754 long nativePss = 0; 14755 long dalvikPss = 0; 14756 long[] dalvikSubitemPss = dumpDalvik ? new long[Debug.MemoryInfo.NUM_DVK_STATS] : 14757 EmptyArray.LONG; 14758 long otherPss = 0; 14759 long[] miscPss = new long[Debug.MemoryInfo.NUM_OTHER_STATS]; 14760 14761 long oomPss[] = new long[DUMP_MEM_OOM_LABEL.length]; 14762 ArrayList<MemItem>[] oomProcs = (ArrayList<MemItem>[]) 14763 new ArrayList[DUMP_MEM_OOM_LABEL.length]; 14764 14765 long totalPss = 0; 14766 long cachedPss = 0; 14767 14768 Debug.MemoryInfo mi = null; 14769 for (int i = procs.size() - 1 ; i >= 0 ; i--) { 14770 final ProcessRecord r = procs.get(i); 14771 final IApplicationThread thread; 14772 final int pid; 14773 final int oomAdj; 14774 final boolean hasActivities; 14775 synchronized (this) { 14776 thread = r.thread; 14777 pid = r.pid; 14778 oomAdj = r.getSetAdjWithServices(); 14779 hasActivities = r.activities.size() > 0; 14780 } 14781 if (thread != null) { 14782 if (!isCheckinRequest && dumpDetails) { 14783 pw.println("\n** MEMINFO in pid " + pid + " [" + r.processName + "] **"); 14784 } 14785 if (mi == null) { 14786 mi = new Debug.MemoryInfo(); 14787 } 14788 if (dumpDetails || (!brief && !oomOnly)) { 14789 Debug.getMemoryInfo(pid, mi); 14790 } else { 14791 mi.dalvikPss = (int)Debug.getPss(pid, tmpLong, null); 14792 mi.dalvikPrivateDirty = (int)tmpLong[0]; 14793 } 14794 if (dumpDetails) { 14795 if (localOnly) { 14796 ActivityThread.dumpMemInfoTable(pw, mi, isCheckinRequest, dumpFullDetails, 14797 dumpDalvik, dumpSummaryOnly, pid, r.processName, 0, 0, 0, 0, 0, 0); 14798 if (isCheckinRequest) { 14799 pw.println(); 14800 } 14801 } else { 14802 try { 14803 pw.flush(); 14804 thread.dumpMemInfo(fd, mi, isCheckinRequest, dumpFullDetails, 14805 dumpDalvik, dumpSummaryOnly, innerArgs); 14806 } catch (RemoteException e) { 14807 if (!isCheckinRequest) { 14808 pw.println("Got RemoteException!"); 14809 pw.flush(); 14810 } 14811 } 14812 } 14813 } 14814 14815 final long myTotalPss = mi.getTotalPss(); 14816 final long myTotalUss = mi.getTotalUss(); 14817 14818 synchronized (this) { 14819 if (r.thread != null && oomAdj == r.getSetAdjWithServices()) { 14820 // Record this for posterity if the process has been stable. 14821 r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true, r.pkgList); 14822 } 14823 } 14824 14825 if (!isCheckinRequest && mi != null) { 14826 totalPss += myTotalPss; 14827 MemItem pssItem = new MemItem(r.processName + " (pid " + pid + 14828 (hasActivities ? " / activities)" : ")"), 14829 r.processName, myTotalPss, pid, hasActivities); 14830 procMems.add(pssItem); 14831 procMemsMap.put(pid, pssItem); 14832 14833 nativePss += mi.nativePss; 14834 dalvikPss += mi.dalvikPss; 14835 for (int j=0; j<dalvikSubitemPss.length; j++) { 14836 dalvikSubitemPss[j] += mi.getOtherPss(Debug.MemoryInfo.NUM_OTHER_STATS + j); 14837 } 14838 otherPss += mi.otherPss; 14839 for (int j=0; j<Debug.MemoryInfo.NUM_OTHER_STATS; j++) { 14840 long mem = mi.getOtherPss(j); 14841 miscPss[j] += mem; 14842 otherPss -= mem; 14843 } 14844 14845 if (oomAdj >= ProcessList.CACHED_APP_MIN_ADJ) { 14846 cachedPss += myTotalPss; 14847 } 14848 14849 for (int oomIndex=0; oomIndex<oomPss.length; oomIndex++) { 14850 if (oomAdj <= DUMP_MEM_OOM_ADJ[oomIndex] 14851 || oomIndex == (oomPss.length-1)) { 14852 oomPss[oomIndex] += myTotalPss; 14853 if (oomProcs[oomIndex] == null) { 14854 oomProcs[oomIndex] = new ArrayList<MemItem>(); 14855 } 14856 oomProcs[oomIndex].add(pssItem); 14857 break; 14858 } 14859 } 14860 } 14861 } 14862 } 14863 14864 long nativeProcTotalPss = 0; 14865 14866 if (!isCheckinRequest && procs.size() > 1 && !packages) { 14867 // If we are showing aggregations, also look for native processes to 14868 // include so that our aggregations are more accurate. 14869 updateCpuStatsNow(); 14870 mi = null; 14871 synchronized (mProcessCpuTracker) { 14872 final int N = mProcessCpuTracker.countStats(); 14873 for (int i=0; i<N; i++) { 14874 ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i); 14875 if (st.vsize > 0 && procMemsMap.indexOfKey(st.pid) < 0) { 14876 if (mi == null) { 14877 mi = new Debug.MemoryInfo(); 14878 } 14879 if (!brief && !oomOnly) { 14880 Debug.getMemoryInfo(st.pid, mi); 14881 } else { 14882 mi.nativePss = (int)Debug.getPss(st.pid, tmpLong, null); 14883 mi.nativePrivateDirty = (int)tmpLong[0]; 14884 } 14885 14886 final long myTotalPss = mi.getTotalPss(); 14887 totalPss += myTotalPss; 14888 nativeProcTotalPss += myTotalPss; 14889 14890 MemItem pssItem = new MemItem(st.name + " (pid " + st.pid + ")", 14891 st.name, myTotalPss, st.pid, false); 14892 procMems.add(pssItem); 14893 14894 nativePss += mi.nativePss; 14895 dalvikPss += mi.dalvikPss; 14896 for (int j=0; j<dalvikSubitemPss.length; j++) { 14897 dalvikSubitemPss[j] += mi.getOtherPss( 14898 Debug.MemoryInfo.NUM_OTHER_STATS + j); 14899 } 14900 otherPss += mi.otherPss; 14901 for (int j=0; j<Debug.MemoryInfo.NUM_OTHER_STATS; j++) { 14902 long mem = mi.getOtherPss(j); 14903 miscPss[j] += mem; 14904 otherPss -= mem; 14905 } 14906 oomPss[0] += myTotalPss; 14907 if (oomProcs[0] == null) { 14908 oomProcs[0] = new ArrayList<MemItem>(); 14909 } 14910 oomProcs[0].add(pssItem); 14911 } 14912 } 14913 } 14914 14915 ArrayList<MemItem> catMems = new ArrayList<MemItem>(); 14916 14917 catMems.add(new MemItem("Native", "Native", nativePss, -1)); 14918 final MemItem dalvikItem = new MemItem("Dalvik", "Dalvik", dalvikPss, -2); 14919 if (dalvikSubitemPss.length > 0) { 14920 dalvikItem.subitems = new ArrayList<MemItem>(); 14921 for (int j=0; j<dalvikSubitemPss.length; j++) { 14922 final String name = Debug.MemoryInfo.getOtherLabel( 14923 Debug.MemoryInfo.NUM_OTHER_STATS + j); 14924 dalvikItem.subitems.add(new MemItem(name, name, dalvikSubitemPss[j], j)); 14925 } 14926 } 14927 catMems.add(dalvikItem); 14928 catMems.add(new MemItem("Unknown", "Unknown", otherPss, -3)); 14929 for (int j=0; j<Debug.MemoryInfo.NUM_OTHER_STATS; j++) { 14930 String label = Debug.MemoryInfo.getOtherLabel(j); 14931 catMems.add(new MemItem(label, label, miscPss[j], j)); 14932 } 14933 14934 ArrayList<MemItem> oomMems = new ArrayList<MemItem>(); 14935 for (int j=0; j<oomPss.length; j++) { 14936 if (oomPss[j] != 0) { 14937 String label = isCompact ? DUMP_MEM_OOM_COMPACT_LABEL[j] 14938 : DUMP_MEM_OOM_LABEL[j]; 14939 MemItem item = new MemItem(label, label, oomPss[j], 14940 DUMP_MEM_OOM_ADJ[j]); 14941 item.subitems = oomProcs[j]; 14942 oomMems.add(item); 14943 } 14944 } 14945 14946 if (!brief && !oomOnly && !isCompact) { 14947 pw.println(); 14948 pw.println("Total PSS by process:"); 14949 dumpMemItems(pw, " ", "proc", procMems, true, isCompact); 14950 pw.println(); 14951 } 14952 if (!isCompact) { 14953 pw.println("Total PSS by OOM adjustment:"); 14954 } 14955 dumpMemItems(pw, " ", "oom", oomMems, false, isCompact); 14956 if (!brief && !oomOnly) { 14957 PrintWriter out = categoryPw != null ? categoryPw : pw; 14958 if (!isCompact) { 14959 out.println(); 14960 out.println("Total PSS by category:"); 14961 } 14962 dumpMemItems(out, " ", "cat", catMems, true, isCompact); 14963 } 14964 if (!isCompact) { 14965 pw.println(); 14966 } 14967 MemInfoReader memInfo = new MemInfoReader(); 14968 memInfo.readMemInfo(); 14969 if (nativeProcTotalPss > 0) { 14970 synchronized (this) { 14971 final long cachedKb = memInfo.getCachedSizeKb(); 14972 final long freeKb = memInfo.getFreeSizeKb(); 14973 final long zramKb = memInfo.getZramTotalSizeKb(); 14974 final long kernelKb = memInfo.getKernelUsedSizeKb(); 14975 EventLogTags.writeAmMeminfo(cachedKb*1024, freeKb*1024, zramKb*1024, 14976 kernelKb*1024, nativeProcTotalPss*1024); 14977 mProcessStats.addSysMemUsageLocked(cachedKb, freeKb, zramKb, kernelKb, 14978 nativeProcTotalPss); 14979 } 14980 } 14981 if (!brief) { 14982 if (!isCompact) { 14983 pw.print("Total RAM: "); pw.print(memInfo.getTotalSizeKb()); 14984 pw.print(" kB (status "); 14985 switch (mLastMemoryLevel) { 14986 case ProcessStats.ADJ_MEM_FACTOR_NORMAL: 14987 pw.println("normal)"); 14988 break; 14989 case ProcessStats.ADJ_MEM_FACTOR_MODERATE: 14990 pw.println("moderate)"); 14991 break; 14992 case ProcessStats.ADJ_MEM_FACTOR_LOW: 14993 pw.println("low)"); 14994 break; 14995 case ProcessStats.ADJ_MEM_FACTOR_CRITICAL: 14996 pw.println("critical)"); 14997 break; 14998 default: 14999 pw.print(mLastMemoryLevel); 15000 pw.println(")"); 15001 break; 15002 } 15003 pw.print(" Free RAM: "); pw.print(cachedPss + memInfo.getCachedSizeKb() 15004 + memInfo.getFreeSizeKb()); pw.print(" kB ("); 15005 pw.print(cachedPss); pw.print(" cached pss + "); 15006 pw.print(memInfo.getCachedSizeKb()); pw.print(" cached kernel + "); 15007 pw.print(memInfo.getFreeSizeKb()); pw.println(" free)"); 15008 } else { 15009 pw.print("ram,"); pw.print(memInfo.getTotalSizeKb()); pw.print(","); 15010 pw.print(cachedPss + memInfo.getCachedSizeKb() 15011 + memInfo.getFreeSizeKb()); pw.print(","); 15012 pw.println(totalPss - cachedPss); 15013 } 15014 } 15015 if (!isCompact) { 15016 pw.print(" Used RAM: "); pw.print(totalPss - cachedPss 15017 + memInfo.getKernelUsedSizeKb()); pw.print(" kB ("); 15018 pw.print(totalPss - cachedPss); pw.print(" used pss + "); 15019 pw.print(memInfo.getKernelUsedSizeKb()); pw.print(" kernel)\n"); 15020 pw.print(" Lost RAM: "); pw.print(memInfo.getTotalSizeKb() 15021 - totalPss - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb() 15022 - memInfo.getKernelUsedSizeKb()); pw.println(" kB"); 15023 } 15024 if (!brief) { 15025 if (memInfo.getZramTotalSizeKb() != 0) { 15026 if (!isCompact) { 15027 pw.print(" ZRAM: "); pw.print(memInfo.getZramTotalSizeKb()); 15028 pw.print(" kB physical used for "); 15029 pw.print(memInfo.getSwapTotalSizeKb() 15030 - memInfo.getSwapFreeSizeKb()); 15031 pw.print(" kB in swap ("); 15032 pw.print(memInfo.getSwapTotalSizeKb()); 15033 pw.println(" kB total swap)"); 15034 } else { 15035 pw.print("zram,"); pw.print(memInfo.getZramTotalSizeKb()); pw.print(","); 15036 pw.print(memInfo.getSwapTotalSizeKb()); pw.print(","); 15037 pw.println(memInfo.getSwapFreeSizeKb()); 15038 } 15039 } 15040 final long[] ksm = getKsmInfo(); 15041 if (!isCompact) { 15042 if (ksm[KSM_SHARING] != 0 || ksm[KSM_SHARED] != 0 || ksm[KSM_UNSHARED] != 0 15043 || ksm[KSM_VOLATILE] != 0) { 15044 pw.print(" KSM: "); pw.print(ksm[KSM_SHARING]); 15045 pw.print(" kB saved from shared "); 15046 pw.print(ksm[KSM_SHARED]); pw.println(" kB"); 15047 pw.print(" "); pw.print(ksm[KSM_UNSHARED]); 15048 pw.print(" kB unshared; "); 15049 pw.print(ksm[KSM_VOLATILE]); pw.println(" kB volatile"); 15050 } 15051 pw.print(" Tuning: "); 15052 pw.print(ActivityManager.staticGetMemoryClass()); 15053 pw.print(" (large "); 15054 pw.print(ActivityManager.staticGetLargeMemoryClass()); 15055 pw.print("), oom "); 15056 pw.print(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ)/1024); 15057 pw.print(" kB"); 15058 pw.print(", restore limit "); 15059 pw.print(mProcessList.getCachedRestoreThresholdKb()); 15060 pw.print(" kB"); 15061 if (ActivityManager.isLowRamDeviceStatic()) { 15062 pw.print(" (low-ram)"); 15063 } 15064 if (ActivityManager.isHighEndGfx()) { 15065 pw.print(" (high-end-gfx)"); 15066 } 15067 pw.println(); 15068 } else { 15069 pw.print("ksm,"); pw.print(ksm[KSM_SHARING]); pw.print(","); 15070 pw.print(ksm[KSM_SHARED]); pw.print(","); pw.print(ksm[KSM_UNSHARED]); 15071 pw.print(","); pw.println(ksm[KSM_VOLATILE]); 15072 pw.print("tuning,"); 15073 pw.print(ActivityManager.staticGetMemoryClass()); 15074 pw.print(','); 15075 pw.print(ActivityManager.staticGetLargeMemoryClass()); 15076 pw.print(','); 15077 pw.print(mProcessList.getMemLevel(ProcessList.CACHED_APP_MAX_ADJ)/1024); 15078 if (ActivityManager.isLowRamDeviceStatic()) { 15079 pw.print(",low-ram"); 15080 } 15081 if (ActivityManager.isHighEndGfx()) { 15082 pw.print(",high-end-gfx"); 15083 } 15084 pw.println(); 15085 } 15086 } 15087 } 15088 } 15089 15090 private void appendBasicMemEntry(StringBuilder sb, int oomAdj, int procState, long pss, 15091 long memtrack, String name) { 15092 sb.append(" "); 15093 sb.append(ProcessList.makeOomAdjString(oomAdj)); 15094 sb.append(' '); 15095 sb.append(ProcessList.makeProcStateString(procState)); 15096 sb.append(' '); 15097 ProcessList.appendRamKb(sb, pss); 15098 sb.append(" kB: "); 15099 sb.append(name); 15100 if (memtrack > 0) { 15101 sb.append(" ("); 15102 sb.append(memtrack); 15103 sb.append(" kB memtrack)"); 15104 } 15105 } 15106 15107 private void appendMemInfo(StringBuilder sb, ProcessMemInfo mi) { 15108 appendBasicMemEntry(sb, mi.oomAdj, mi.procState, mi.pss, mi.memtrack, mi.name); 15109 sb.append(" (pid "); 15110 sb.append(mi.pid); 15111 sb.append(") "); 15112 sb.append(mi.adjType); 15113 sb.append('\n'); 15114 if (mi.adjReason != null) { 15115 sb.append(" "); 15116 sb.append(mi.adjReason); 15117 sb.append('\n'); 15118 } 15119 } 15120 15121 void reportMemUsage(ArrayList<ProcessMemInfo> memInfos) { 15122 final SparseArray<ProcessMemInfo> infoMap = new SparseArray<>(memInfos.size()); 15123 for (int i=0, N=memInfos.size(); i<N; i++) { 15124 ProcessMemInfo mi = memInfos.get(i); 15125 infoMap.put(mi.pid, mi); 15126 } 15127 updateCpuStatsNow(); 15128 long[] memtrackTmp = new long[1]; 15129 synchronized (mProcessCpuTracker) { 15130 final int N = mProcessCpuTracker.countStats(); 15131 for (int i=0; i<N; i++) { 15132 ProcessCpuTracker.Stats st = mProcessCpuTracker.getStats(i); 15133 if (st.vsize > 0) { 15134 long pss = Debug.getPss(st.pid, null, memtrackTmp); 15135 if (pss > 0) { 15136 if (infoMap.indexOfKey(st.pid) < 0) { 15137 ProcessMemInfo mi = new ProcessMemInfo(st.name, st.pid, 15138 ProcessList.NATIVE_ADJ, -1, "native", null); 15139 mi.pss = pss; 15140 mi.memtrack = memtrackTmp[0]; 15141 memInfos.add(mi); 15142 } 15143 } 15144 } 15145 } 15146 } 15147 15148 long totalPss = 0; 15149 long totalMemtrack = 0; 15150 for (int i=0, N=memInfos.size(); i<N; i++) { 15151 ProcessMemInfo mi = memInfos.get(i); 15152 if (mi.pss == 0) { 15153 mi.pss = Debug.getPss(mi.pid, null, memtrackTmp); 15154 mi.memtrack = memtrackTmp[0]; 15155 } 15156 totalPss += mi.pss; 15157 totalMemtrack += mi.memtrack; 15158 } 15159 Collections.sort(memInfos, new Comparator<ProcessMemInfo>() { 15160 @Override public int compare(ProcessMemInfo lhs, ProcessMemInfo rhs) { 15161 if (lhs.oomAdj != rhs.oomAdj) { 15162 return lhs.oomAdj < rhs.oomAdj ? -1 : 1; 15163 } 15164 if (lhs.pss != rhs.pss) { 15165 return lhs.pss < rhs.pss ? 1 : -1; 15166 } 15167 return 0; 15168 } 15169 }); 15170 15171 StringBuilder tag = new StringBuilder(128); 15172 StringBuilder stack = new StringBuilder(128); 15173 tag.append("Low on memory -- "); 15174 appendMemBucket(tag, totalPss, "total", false); 15175 appendMemBucket(stack, totalPss, "total", true); 15176 15177 StringBuilder fullNativeBuilder = new StringBuilder(1024); 15178 StringBuilder shortNativeBuilder = new StringBuilder(1024); 15179 StringBuilder fullJavaBuilder = new StringBuilder(1024); 15180 15181 boolean firstLine = true; 15182 int lastOomAdj = Integer.MIN_VALUE; 15183 long extraNativeRam = 0; 15184 long extraNativeMemtrack = 0; 15185 long cachedPss = 0; 15186 for (int i=0, N=memInfos.size(); i<N; i++) { 15187 ProcessMemInfo mi = memInfos.get(i); 15188 15189 if (mi.oomAdj >= ProcessList.CACHED_APP_MIN_ADJ) { 15190 cachedPss += mi.pss; 15191 } 15192 15193 if (mi.oomAdj != ProcessList.NATIVE_ADJ 15194 && (mi.oomAdj < ProcessList.SERVICE_ADJ 15195 || mi.oomAdj == ProcessList.HOME_APP_ADJ 15196 || mi.oomAdj == ProcessList.PREVIOUS_APP_ADJ)) { 15197 if (lastOomAdj != mi.oomAdj) { 15198 lastOomAdj = mi.oomAdj; 15199 if (mi.oomAdj <= ProcessList.FOREGROUND_APP_ADJ) { 15200 tag.append(" / "); 15201 } 15202 if (mi.oomAdj >= ProcessList.FOREGROUND_APP_ADJ) { 15203 if (firstLine) { 15204 stack.append(":"); 15205 firstLine = false; 15206 } 15207 stack.append("\n\t at "); 15208 } else { 15209 stack.append("$"); 15210 } 15211 } else { 15212 tag.append(" "); 15213 stack.append("$"); 15214 } 15215 if (mi.oomAdj <= ProcessList.FOREGROUND_APP_ADJ) { 15216 appendMemBucket(tag, mi.pss, mi.name, false); 15217 } 15218 appendMemBucket(stack, mi.pss, mi.name, true); 15219 if (mi.oomAdj >= ProcessList.FOREGROUND_APP_ADJ 15220 && ((i+1) >= N || memInfos.get(i+1).oomAdj != lastOomAdj)) { 15221 stack.append("("); 15222 for (int k=0; k<DUMP_MEM_OOM_ADJ.length; k++) { 15223 if (DUMP_MEM_OOM_ADJ[k] == mi.oomAdj) { 15224 stack.append(DUMP_MEM_OOM_LABEL[k]); 15225 stack.append(":"); 15226 stack.append(DUMP_MEM_OOM_ADJ[k]); 15227 } 15228 } 15229 stack.append(")"); 15230 } 15231 } 15232 15233 appendMemInfo(fullNativeBuilder, mi); 15234 if (mi.oomAdj == ProcessList.NATIVE_ADJ) { 15235 // The short form only has native processes that are >= 512K. 15236 if (mi.pss >= 512) { 15237 appendMemInfo(shortNativeBuilder, mi); 15238 } else { 15239 extraNativeRam += mi.pss; 15240 extraNativeMemtrack += mi.memtrack; 15241 } 15242 } else { 15243 // Short form has all other details, but if we have collected RAM 15244 // from smaller native processes let's dump a summary of that. 15245 if (extraNativeRam > 0) { 15246 appendBasicMemEntry(shortNativeBuilder, ProcessList.NATIVE_ADJ, 15247 -1, extraNativeRam, extraNativeMemtrack, "(Other native)"); 15248 shortNativeBuilder.append('\n'); 15249 extraNativeRam = 0; 15250 } 15251 appendMemInfo(fullJavaBuilder, mi); 15252 } 15253 } 15254 15255 fullJavaBuilder.append(" "); 15256 ProcessList.appendRamKb(fullJavaBuilder, totalPss); 15257 fullJavaBuilder.append(" kB: TOTAL"); 15258 if (totalMemtrack > 0) { 15259 fullJavaBuilder.append(" ("); 15260 fullJavaBuilder.append(totalMemtrack); 15261 fullJavaBuilder.append(" kB memtrack)"); 15262 } else { 15263 } 15264 fullJavaBuilder.append("\n"); 15265 15266 MemInfoReader memInfo = new MemInfoReader(); 15267 memInfo.readMemInfo(); 15268 final long[] infos = memInfo.getRawInfo(); 15269 15270 StringBuilder memInfoBuilder = new StringBuilder(1024); 15271 Debug.getMemInfo(infos); 15272 memInfoBuilder.append(" MemInfo: "); 15273 memInfoBuilder.append(infos[Debug.MEMINFO_SLAB]).append(" kB slab, "); 15274 memInfoBuilder.append(infos[Debug.MEMINFO_SHMEM]).append(" kB shmem, "); 15275 memInfoBuilder.append(infos[Debug.MEMINFO_VM_ALLOC_USED]).append(" kB vm alloc, "); 15276 memInfoBuilder.append(infos[Debug.MEMINFO_PAGE_TABLES]).append(" kB page tables "); 15277 memInfoBuilder.append(infos[Debug.MEMINFO_KERNEL_STACK]).append(" kB kernel stack\n"); 15278 memInfoBuilder.append(" "); 15279 memInfoBuilder.append(infos[Debug.MEMINFO_BUFFERS]).append(" kB buffers, "); 15280 memInfoBuilder.append(infos[Debug.MEMINFO_CACHED]).append(" kB cached, "); 15281 memInfoBuilder.append(infos[Debug.MEMINFO_MAPPED]).append(" kB mapped, "); 15282 memInfoBuilder.append(infos[Debug.MEMINFO_FREE]).append(" kB free\n"); 15283 if (infos[Debug.MEMINFO_ZRAM_TOTAL] != 0) { 15284 memInfoBuilder.append(" ZRAM: "); 15285 memInfoBuilder.append(infos[Debug.MEMINFO_ZRAM_TOTAL]); 15286 memInfoBuilder.append(" kB RAM, "); 15287 memInfoBuilder.append(infos[Debug.MEMINFO_SWAP_TOTAL]); 15288 memInfoBuilder.append(" kB swap total, "); 15289 memInfoBuilder.append(infos[Debug.MEMINFO_SWAP_FREE]); 15290 memInfoBuilder.append(" kB swap free\n"); 15291 } 15292 final long[] ksm = getKsmInfo(); 15293 if (ksm[KSM_SHARING] != 0 || ksm[KSM_SHARED] != 0 || ksm[KSM_UNSHARED] != 0 15294 || ksm[KSM_VOLATILE] != 0) { 15295 memInfoBuilder.append(" KSM: "); memInfoBuilder.append(ksm[KSM_SHARING]); 15296 memInfoBuilder.append(" kB saved from shared "); 15297 memInfoBuilder.append(ksm[KSM_SHARED]); memInfoBuilder.append(" kB\n"); 15298 memInfoBuilder.append(" "); memInfoBuilder.append(ksm[KSM_UNSHARED]); 15299 memInfoBuilder.append(" kB unshared; "); 15300 memInfoBuilder.append(ksm[KSM_VOLATILE]); memInfoBuilder.append(" kB volatile\n"); 15301 } 15302 memInfoBuilder.append(" Free RAM: "); 15303 memInfoBuilder.append(cachedPss + memInfo.getCachedSizeKb() 15304 + memInfo.getFreeSizeKb()); 15305 memInfoBuilder.append(" kB\n"); 15306 memInfoBuilder.append(" Used RAM: "); 15307 memInfoBuilder.append(totalPss - cachedPss + memInfo.getKernelUsedSizeKb()); 15308 memInfoBuilder.append(" kB\n"); 15309 memInfoBuilder.append(" Lost RAM: "); 15310 memInfoBuilder.append(memInfo.getTotalSizeKb() 15311 - totalPss - memInfo.getFreeSizeKb() - memInfo.getCachedSizeKb() 15312 - memInfo.getKernelUsedSizeKb()); 15313 memInfoBuilder.append(" kB\n"); 15314 Slog.i(TAG, "Low on memory:"); 15315 Slog.i(TAG, shortNativeBuilder.toString()); 15316 Slog.i(TAG, fullJavaBuilder.toString()); 15317 Slog.i(TAG, memInfoBuilder.toString()); 15318 15319 StringBuilder dropBuilder = new StringBuilder(1024); 15320 /* 15321 StringWriter oomSw = new StringWriter(); 15322 PrintWriter oomPw = new FastPrintWriter(oomSw, false, 256); 15323 StringWriter catSw = new StringWriter(); 15324 PrintWriter catPw = new FastPrintWriter(catSw, false, 256); 15325 String[] emptyArgs = new String[] { }; 15326 dumpApplicationMemoryUsage(null, oomPw, " ", emptyArgs, true, catPw); 15327 oomPw.flush(); 15328 String oomString = oomSw.toString(); 15329 */ 15330 dropBuilder.append("Low on memory:"); 15331 dropBuilder.append(stack); 15332 dropBuilder.append('\n'); 15333 dropBuilder.append(fullNativeBuilder); 15334 dropBuilder.append(fullJavaBuilder); 15335 dropBuilder.append('\n'); 15336 dropBuilder.append(memInfoBuilder); 15337 dropBuilder.append('\n'); 15338 /* 15339 dropBuilder.append(oomString); 15340 dropBuilder.append('\n'); 15341 */ 15342 StringWriter catSw = new StringWriter(); 15343 synchronized (ActivityManagerService.this) { 15344 PrintWriter catPw = new FastPrintWriter(catSw, false, 256); 15345 String[] emptyArgs = new String[] { }; 15346 catPw.println(); 15347 dumpProcessesLocked(null, catPw, emptyArgs, 0, false, null); 15348 catPw.println(); 15349 mServices.dumpServicesLocked(null, catPw, emptyArgs, 0, 15350 false, false, null); 15351 catPw.println(); 15352 dumpActivitiesLocked(null, catPw, emptyArgs, 0, false, false, null); 15353 catPw.flush(); 15354 } 15355 dropBuilder.append(catSw.toString()); 15356 addErrorToDropBox("lowmem", null, "system_server", null, 15357 null, tag.toString(), dropBuilder.toString(), null, null); 15358 //Slog.i(TAG, "Sent to dropbox:"); 15359 //Slog.i(TAG, dropBuilder.toString()); 15360 synchronized (ActivityManagerService.this) { 15361 long now = SystemClock.uptimeMillis(); 15362 if (mLastMemUsageReportTime < now) { 15363 mLastMemUsageReportTime = now; 15364 } 15365 } 15366 } 15367 15368 /** 15369 * Searches array of arguments for the specified string 15370 * @param args array of argument strings 15371 * @param value value to search for 15372 * @return true if the value is contained in the array 15373 */ 15374 private static boolean scanArgs(String[] args, String value) { 15375 if (args != null) { 15376 for (String arg : args) { 15377 if (value.equals(arg)) { 15378 return true; 15379 } 15380 } 15381 } 15382 return false; 15383 } 15384 15385 private final boolean removeDyingProviderLocked(ProcessRecord proc, 15386 ContentProviderRecord cpr, boolean always) { 15387 final boolean inLaunching = mLaunchingProviders.contains(cpr); 15388 15389 if (!inLaunching || always) { 15390 synchronized (cpr) { 15391 cpr.launchingApp = null; 15392 cpr.notifyAll(); 15393 } 15394 mProviderMap.removeProviderByClass(cpr.name, UserHandle.getUserId(cpr.uid)); 15395 String names[] = cpr.info.authority.split(";"); 15396 for (int j = 0; j < names.length; j++) { 15397 mProviderMap.removeProviderByName(names[j], UserHandle.getUserId(cpr.uid)); 15398 } 15399 } 15400 15401 for (int i = cpr.connections.size() - 1; i >= 0; i--) { 15402 ContentProviderConnection conn = cpr.connections.get(i); 15403 if (conn.waiting) { 15404 // If this connection is waiting for the provider, then we don't 15405 // need to mess with its process unless we are always removing 15406 // or for some reason the provider is not currently launching. 15407 if (inLaunching && !always) { 15408 continue; 15409 } 15410 } 15411 ProcessRecord capp = conn.client; 15412 conn.dead = true; 15413 if (conn.stableCount > 0) { 15414 if (!capp.persistent && capp.thread != null 15415 && capp.pid != 0 15416 && capp.pid != MY_PID) { 15417 capp.kill("depends on provider " 15418 + cpr.name.flattenToShortString() 15419 + " in dying proc " + (proc != null ? proc.processName : "??"), true); 15420 } 15421 } else if (capp.thread != null && conn.provider.provider != null) { 15422 try { 15423 capp.thread.unstableProviderDied(conn.provider.provider.asBinder()); 15424 } catch (RemoteException e) { 15425 } 15426 // In the protocol here, we don't expect the client to correctly 15427 // clean up this connection, we'll just remove it. 15428 cpr.connections.remove(i); 15429 if (conn.client.conProviders.remove(conn)) { 15430 stopAssociationLocked(capp.uid, capp.processName, cpr.uid, cpr.name); 15431 } 15432 } 15433 } 15434 15435 if (inLaunching && always) { 15436 mLaunchingProviders.remove(cpr); 15437 } 15438 return inLaunching; 15439 } 15440 15441 /** 15442 * Main code for cleaning up a process when it has gone away. This is 15443 * called both as a result of the process dying, or directly when stopping 15444 * a process when running in single process mode. 15445 * 15446 * @return Returns true if the given process has been restarted, so the 15447 * app that was passed in must remain on the process lists. 15448 */ 15449 private final boolean cleanUpApplicationRecordLocked(ProcessRecord app, 15450 boolean restarting, boolean allowRestart, int index) { 15451 if (index >= 0) { 15452 removeLruProcessLocked(app); 15453 ProcessList.remove(app.pid); 15454 } 15455 15456 mProcessesToGc.remove(app); 15457 mPendingPssProcesses.remove(app); 15458 15459 // Dismiss any open dialogs. 15460 if (app.crashDialog != null && !app.forceCrashReport) { 15461 app.crashDialog.dismiss(); 15462 app.crashDialog = null; 15463 } 15464 if (app.anrDialog != null) { 15465 app.anrDialog.dismiss(); 15466 app.anrDialog = null; 15467 } 15468 if (app.waitDialog != null) { 15469 app.waitDialog.dismiss(); 15470 app.waitDialog = null; 15471 } 15472 15473 app.crashing = false; 15474 app.notResponding = false; 15475 15476 app.resetPackageList(mProcessStats); 15477 app.unlinkDeathRecipient(); 15478 app.makeInactive(mProcessStats); 15479 app.waitingToKill = null; 15480 app.forcingToForeground = null; 15481 updateProcessForegroundLocked(app, false, false); 15482 app.foregroundActivities = false; 15483 app.hasShownUi = false; 15484 app.treatLikeActivity = false; 15485 app.hasAboveClient = false; 15486 app.hasClientActivities = false; 15487 15488 mServices.killServicesLocked(app, allowRestart); 15489 15490 boolean restart = false; 15491 15492 // Remove published content providers. 15493 for (int i = app.pubProviders.size() - 1; i >= 0; i--) { 15494 ContentProviderRecord cpr = app.pubProviders.valueAt(i); 15495 final boolean always = app.bad || !allowRestart; 15496 boolean inLaunching = removeDyingProviderLocked(app, cpr, always); 15497 if ((inLaunching || always) && cpr.hasConnectionOrHandle()) { 15498 // We left the provider in the launching list, need to 15499 // restart it. 15500 restart = true; 15501 } 15502 15503 cpr.provider = null; 15504 cpr.proc = null; 15505 } 15506 app.pubProviders.clear(); 15507 15508 // Take care of any launching providers waiting for this process. 15509 if (checkAppInLaunchingProvidersLocked(app, false)) { 15510 restart = true; 15511 } 15512 15513 // Unregister from connected content providers. 15514 if (!app.conProviders.isEmpty()) { 15515 for (int i = app.conProviders.size() - 1; i >= 0; i--) { 15516 ContentProviderConnection conn = app.conProviders.get(i); 15517 conn.provider.connections.remove(conn); 15518 stopAssociationLocked(app.uid, app.processName, conn.provider.uid, 15519 conn.provider.name); 15520 } 15521 app.conProviders.clear(); 15522 } 15523 15524 // At this point there may be remaining entries in mLaunchingProviders 15525 // where we were the only one waiting, so they are no longer of use. 15526 // Look for these and clean up if found. 15527 // XXX Commented out for now. Trying to figure out a way to reproduce 15528 // the actual situation to identify what is actually going on. 15529 if (false) { 15530 for (int i = mLaunchingProviders.size() - 1; i >= 0; i--) { 15531 ContentProviderRecord cpr = mLaunchingProviders.get(i); 15532 if (cpr.connections.size() <= 0 && !cpr.hasExternalProcessHandles()) { 15533 synchronized (cpr) { 15534 cpr.launchingApp = null; 15535 cpr.notifyAll(); 15536 } 15537 } 15538 } 15539 } 15540 15541 skipCurrentReceiverLocked(app); 15542 15543 // Unregister any receivers. 15544 for (int i = app.receivers.size() - 1; i >= 0; i--) { 15545 removeReceiverLocked(app.receivers.valueAt(i)); 15546 } 15547 app.receivers.clear(); 15548 15549 // If the app is undergoing backup, tell the backup manager about it 15550 if (mBackupTarget != null && app.pid == mBackupTarget.app.pid) { 15551 if (DEBUG_BACKUP || DEBUG_CLEANUP) Slog.d(TAG_CLEANUP, "App " 15552 + mBackupTarget.appInfo + " died during backup"); 15553 try { 15554 IBackupManager bm = IBackupManager.Stub.asInterface( 15555 ServiceManager.getService(Context.BACKUP_SERVICE)); 15556 bm.agentDisconnected(app.info.packageName); 15557 } catch (RemoteException e) { 15558 // can't happen; backup manager is local 15559 } 15560 } 15561 15562 for (int i = mPendingProcessChanges.size() - 1; i >= 0; i--) { 15563 ProcessChangeItem item = mPendingProcessChanges.get(i); 15564 if (item.pid == app.pid) { 15565 mPendingProcessChanges.remove(i); 15566 mAvailProcessChanges.add(item); 15567 } 15568 } 15569 mUiHandler.obtainMessage(DISPATCH_PROCESS_DIED, app.pid, app.info.uid, null).sendToTarget(); 15570 15571 // If the caller is restarting this app, then leave it in its 15572 // current lists and let the caller take care of it. 15573 if (restarting) { 15574 return false; 15575 } 15576 15577 if (!app.persistent || app.isolated) { 15578 if (DEBUG_PROCESSES || DEBUG_CLEANUP) Slog.v(TAG_CLEANUP, 15579 "Removing non-persistent process during cleanup: " + app); 15580 removeProcessNameLocked(app.processName, app.uid); 15581 if (mHeavyWeightProcess == app) { 15582 mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG, 15583 mHeavyWeightProcess.userId, 0)); 15584 mHeavyWeightProcess = null; 15585 } 15586 } else if (!app.removed) { 15587 // This app is persistent, so we need to keep its record around. 15588 // If it is not already on the pending app list, add it there 15589 // and start a new process for it. 15590 if (mPersistentStartingProcesses.indexOf(app) < 0) { 15591 mPersistentStartingProcesses.add(app); 15592 restart = true; 15593 } 15594 } 15595 if ((DEBUG_PROCESSES || DEBUG_CLEANUP) && mProcessesOnHold.contains(app)) Slog.v( 15596 TAG_CLEANUP, "Clean-up removing on hold: " + app); 15597 mProcessesOnHold.remove(app); 15598 15599 if (app == mHomeProcess) { 15600 mHomeProcess = null; 15601 } 15602 if (app == mPreviousProcess) { 15603 mPreviousProcess = null; 15604 } 15605 15606 if (restart && !app.isolated) { 15607 // We have components that still need to be running in the 15608 // process, so re-launch it. 15609 if (index < 0) { 15610 ProcessList.remove(app.pid); 15611 } 15612 addProcessNameLocked(app); 15613 startProcessLocked(app, "restart", app.processName); 15614 return true; 15615 } else if (app.pid > 0 && app.pid != MY_PID) { 15616 // Goodbye! 15617 boolean removed; 15618 synchronized (mPidsSelfLocked) { 15619 mPidsSelfLocked.remove(app.pid); 15620 mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); 15621 } 15622 mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid); 15623 if (app.isolated) { 15624 mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid); 15625 } 15626 app.setPid(0); 15627 } 15628 return false; 15629 } 15630 15631 boolean checkAppInLaunchingProvidersLocked(ProcessRecord app, boolean alwaysBad) { 15632 // Look through the content providers we are waiting to have launched, 15633 // and if any run in this process then either schedule a restart of 15634 // the process or kill the client waiting for it if this process has 15635 // gone bad. 15636 boolean restart = false; 15637 for (int i = mLaunchingProviders.size() - 1; i >= 0; i--) { 15638 ContentProviderRecord cpr = mLaunchingProviders.get(i); 15639 if (cpr.launchingApp == app) { 15640 if (!alwaysBad && !app.bad && cpr.hasConnectionOrHandle()) { 15641 restart = true; 15642 } else { 15643 removeDyingProviderLocked(app, cpr, true); 15644 } 15645 } 15646 } 15647 return restart; 15648 } 15649 15650 // ========================================================= 15651 // SERVICES 15652 // ========================================================= 15653 15654 @Override 15655 public List<ActivityManager.RunningServiceInfo> getServices(int maxNum, 15656 int flags) { 15657 enforceNotIsolatedCaller("getServices"); 15658 synchronized (this) { 15659 return mServices.getRunningServiceInfoLocked(maxNum, flags); 15660 } 15661 } 15662 15663 @Override 15664 public PendingIntent getRunningServiceControlPanel(ComponentName name) { 15665 enforceNotIsolatedCaller("getRunningServiceControlPanel"); 15666 synchronized (this) { 15667 return mServices.getRunningServiceControlPanelLocked(name); 15668 } 15669 } 15670 15671 @Override 15672 public ComponentName startService(IApplicationThread caller, Intent service, 15673 String resolvedType, String callingPackage, int userId) 15674 throws TransactionTooLargeException { 15675 enforceNotIsolatedCaller("startService"); 15676 // Refuse possible leaked file descriptors 15677 if (service != null && service.hasFileDescriptors() == true) { 15678 throw new IllegalArgumentException("File descriptors passed in Intent"); 15679 } 15680 15681 if (callingPackage == null) { 15682 throw new IllegalArgumentException("callingPackage cannot be null"); 15683 } 15684 15685 if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, 15686 "startService: " + service + " type=" + resolvedType); 15687 synchronized(this) { 15688 final int callingPid = Binder.getCallingPid(); 15689 final int callingUid = Binder.getCallingUid(); 15690 final long origId = Binder.clearCallingIdentity(); 15691 ComponentName res = mServices.startServiceLocked(caller, service, 15692 resolvedType, callingPid, callingUid, callingPackage, userId); 15693 Binder.restoreCallingIdentity(origId); 15694 return res; 15695 } 15696 } 15697 15698 ComponentName startServiceInPackage(int uid, Intent service, String resolvedType, 15699 String callingPackage, int userId) 15700 throws TransactionTooLargeException { 15701 synchronized(this) { 15702 if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, 15703 "startServiceInPackage: " + service + " type=" + resolvedType); 15704 final long origId = Binder.clearCallingIdentity(); 15705 ComponentName res = mServices.startServiceLocked(null, service, 15706 resolvedType, -1, uid, callingPackage, userId); 15707 Binder.restoreCallingIdentity(origId); 15708 return res; 15709 } 15710 } 15711 15712 @Override 15713 public int stopService(IApplicationThread caller, Intent service, 15714 String resolvedType, int userId) { 15715 enforceNotIsolatedCaller("stopService"); 15716 // Refuse possible leaked file descriptors 15717 if (service != null && service.hasFileDescriptors() == true) { 15718 throw new IllegalArgumentException("File descriptors passed in Intent"); 15719 } 15720 15721 synchronized(this) { 15722 return mServices.stopServiceLocked(caller, service, resolvedType, userId); 15723 } 15724 } 15725 15726 @Override 15727 public IBinder peekService(Intent service, String resolvedType, String callingPackage) { 15728 enforceNotIsolatedCaller("peekService"); 15729 // Refuse possible leaked file descriptors 15730 if (service != null && service.hasFileDescriptors() == true) { 15731 throw new IllegalArgumentException("File descriptors passed in Intent"); 15732 } 15733 15734 if (callingPackage == null) { 15735 throw new IllegalArgumentException("callingPackage cannot be null"); 15736 } 15737 15738 synchronized(this) { 15739 return mServices.peekServiceLocked(service, resolvedType, callingPackage); 15740 } 15741 } 15742 15743 @Override 15744 public boolean stopServiceToken(ComponentName className, IBinder token, 15745 int startId) { 15746 synchronized(this) { 15747 return mServices.stopServiceTokenLocked(className, token, startId); 15748 } 15749 } 15750 15751 @Override 15752 public void setServiceForeground(ComponentName className, IBinder token, 15753 int id, Notification notification, boolean removeNotification) { 15754 synchronized(this) { 15755 mServices.setServiceForegroundLocked(className, token, id, notification, 15756 removeNotification); 15757 } 15758 } 15759 15760 @Override 15761 public int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll, 15762 boolean requireFull, String name, String callerPackage) { 15763 return handleIncomingUser(callingPid, callingUid, userId, allowAll, 15764 requireFull ? ALLOW_FULL_ONLY : ALLOW_NON_FULL, name, callerPackage); 15765 } 15766 15767 int unsafeConvertIncomingUser(int userId) { 15768 return (userId == UserHandle.USER_CURRENT || userId == UserHandle.USER_CURRENT_OR_SELF) 15769 ? mCurrentUserId : userId; 15770 } 15771 15772 int handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll, 15773 int allowMode, String name, String callerPackage) { 15774 final int callingUserId = UserHandle.getUserId(callingUid); 15775 if (callingUserId == userId) { 15776 return userId; 15777 } 15778 15779 // Note that we may be accessing mCurrentUserId outside of a lock... 15780 // shouldn't be a big deal, if this is being called outside 15781 // of a locked context there is intrinsically a race with 15782 // the value the caller will receive and someone else changing it. 15783 // We assume that USER_CURRENT_OR_SELF will use the current user; later 15784 // we will switch to the calling user if access to the current user fails. 15785 int targetUserId = unsafeConvertIncomingUser(userId); 15786 15787 if (callingUid != 0 && callingUid != Process.SYSTEM_UID) { 15788 final boolean allow; 15789 if (checkComponentPermission(INTERACT_ACROSS_USERS_FULL, callingPid, 15790 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED) { 15791 // If the caller has this permission, they always pass go. And collect $200. 15792 allow = true; 15793 } else if (allowMode == ALLOW_FULL_ONLY) { 15794 // We require full access, sucks to be you. 15795 allow = false; 15796 } else if (checkComponentPermission(INTERACT_ACROSS_USERS, callingPid, 15797 callingUid, -1, true) != PackageManager.PERMISSION_GRANTED) { 15798 // If the caller does not have either permission, they are always doomed. 15799 allow = false; 15800 } else if (allowMode == ALLOW_NON_FULL) { 15801 // We are blanket allowing non-full access, you lucky caller! 15802 allow = true; 15803 } else if (allowMode == ALLOW_NON_FULL_IN_PROFILE) { 15804 // We may or may not allow this depending on whether the two users are 15805 // in the same profile. 15806 synchronized (mUserProfileGroupIdsSelfLocked) { 15807 int callingProfile = mUserProfileGroupIdsSelfLocked.get(callingUserId, 15808 UserInfo.NO_PROFILE_GROUP_ID); 15809 int targetProfile = mUserProfileGroupIdsSelfLocked.get(targetUserId, 15810 UserInfo.NO_PROFILE_GROUP_ID); 15811 allow = callingProfile != UserInfo.NO_PROFILE_GROUP_ID 15812 && callingProfile == targetProfile; 15813 } 15814 } else { 15815 throw new IllegalArgumentException("Unknown mode: " + allowMode); 15816 } 15817 if (!allow) { 15818 if (userId == UserHandle.USER_CURRENT_OR_SELF) { 15819 // In this case, they would like to just execute as their 15820 // owner user instead of failing. 15821 targetUserId = callingUserId; 15822 } else { 15823 StringBuilder builder = new StringBuilder(128); 15824 builder.append("Permission Denial: "); 15825 builder.append(name); 15826 if (callerPackage != null) { 15827 builder.append(" from "); 15828 builder.append(callerPackage); 15829 } 15830 builder.append(" asks to run as user "); 15831 builder.append(userId); 15832 builder.append(" but is calling from user "); 15833 builder.append(UserHandle.getUserId(callingUid)); 15834 builder.append("; this requires "); 15835 builder.append(INTERACT_ACROSS_USERS_FULL); 15836 if (allowMode != ALLOW_FULL_ONLY) { 15837 builder.append(" or "); 15838 builder.append(INTERACT_ACROSS_USERS); 15839 } 15840 String msg = builder.toString(); 15841 Slog.w(TAG, msg); 15842 throw new SecurityException(msg); 15843 } 15844 } 15845 } 15846 if (!allowAll && targetUserId < 0) { 15847 throw new IllegalArgumentException( 15848 "Call does not support special user #" + targetUserId); 15849 } 15850 // Check shell permission 15851 if (callingUid == Process.SHELL_UID && targetUserId >= UserHandle.USER_OWNER) { 15852 if (mUserManager.hasUserRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, 15853 targetUserId)) { 15854 throw new SecurityException("Shell does not have permission to access user " 15855 + targetUserId + "\n " + Debug.getCallers(3)); 15856 } 15857 } 15858 return targetUserId; 15859 } 15860 15861 boolean isSingleton(String componentProcessName, ApplicationInfo aInfo, 15862 String className, int flags) { 15863 boolean result = false; 15864 // For apps that don't have pre-defined UIDs, check for permission 15865 if (UserHandle.getAppId(aInfo.uid) >= Process.FIRST_APPLICATION_UID) { 15866 if ((flags & ServiceInfo.FLAG_SINGLE_USER) != 0) { 15867 if (ActivityManager.checkUidPermission( 15868 INTERACT_ACROSS_USERS, 15869 aInfo.uid) != PackageManager.PERMISSION_GRANTED) { 15870 ComponentName comp = new ComponentName(aInfo.packageName, className); 15871 String msg = "Permission Denial: Component " + comp.flattenToShortString() 15872 + " requests FLAG_SINGLE_USER, but app does not hold " 15873 + INTERACT_ACROSS_USERS; 15874 Slog.w(TAG, msg); 15875 throw new SecurityException(msg); 15876 } 15877 // Permission passed 15878 result = true; 15879 } 15880 } else if ("system".equals(componentProcessName)) { 15881 result = true; 15882 } else if ((flags & ServiceInfo.FLAG_SINGLE_USER) != 0) { 15883 // Phone app and persistent apps are allowed to export singleuser providers. 15884 result = UserHandle.isSameApp(aInfo.uid, Process.PHONE_UID) 15885 || (aInfo.flags & ApplicationInfo.FLAG_PERSISTENT) != 0; 15886 } 15887 if (DEBUG_MU) Slog.v(TAG_MU, 15888 "isSingleton(" + componentProcessName + ", " + aInfo + ", " + className + ", 0x" 15889 + Integer.toHexString(flags) + ") = " + result); 15890 return result; 15891 } 15892 15893 /** 15894 * Checks to see if the caller is in the same app as the singleton 15895 * component, or the component is in a special app. It allows special apps 15896 * to export singleton components but prevents exporting singleton 15897 * components for regular apps. 15898 */ 15899 boolean isValidSingletonCall(int callingUid, int componentUid) { 15900 int componentAppId = UserHandle.getAppId(componentUid); 15901 return UserHandle.isSameApp(callingUid, componentUid) 15902 || componentAppId == Process.SYSTEM_UID 15903 || componentAppId == Process.PHONE_UID 15904 || ActivityManager.checkUidPermission(INTERACT_ACROSS_USERS_FULL, componentUid) 15905 == PackageManager.PERMISSION_GRANTED; 15906 } 15907 15908 public int bindService(IApplicationThread caller, IBinder token, Intent service, 15909 String resolvedType, IServiceConnection connection, int flags, String callingPackage, 15910 int userId) throws TransactionTooLargeException { 15911 enforceNotIsolatedCaller("bindService"); 15912 15913 // Refuse possible leaked file descriptors 15914 if (service != null && service.hasFileDescriptors() == true) { 15915 throw new IllegalArgumentException("File descriptors passed in Intent"); 15916 } 15917 15918 if (callingPackage == null) { 15919 throw new IllegalArgumentException("callingPackage cannot be null"); 15920 } 15921 15922 synchronized(this) { 15923 return mServices.bindServiceLocked(caller, token, service, 15924 resolvedType, connection, flags, callingPackage, userId); 15925 } 15926 } 15927 15928 public boolean unbindService(IServiceConnection connection) { 15929 synchronized (this) { 15930 return mServices.unbindServiceLocked(connection); 15931 } 15932 } 15933 15934 public void publishService(IBinder token, Intent intent, IBinder service) { 15935 // Refuse possible leaked file descriptors 15936 if (intent != null && intent.hasFileDescriptors() == true) { 15937 throw new IllegalArgumentException("File descriptors passed in Intent"); 15938 } 15939 15940 synchronized(this) { 15941 if (!(token instanceof ServiceRecord)) { 15942 throw new IllegalArgumentException("Invalid service token"); 15943 } 15944 mServices.publishServiceLocked((ServiceRecord)token, intent, service); 15945 } 15946 } 15947 15948 public void unbindFinished(IBinder token, Intent intent, boolean doRebind) { 15949 // Refuse possible leaked file descriptors 15950 if (intent != null && intent.hasFileDescriptors() == true) { 15951 throw new IllegalArgumentException("File descriptors passed in Intent"); 15952 } 15953 15954 synchronized(this) { 15955 mServices.unbindFinishedLocked((ServiceRecord)token, intent, doRebind); 15956 } 15957 } 15958 15959 public void serviceDoneExecuting(IBinder token, int type, int startId, int res) { 15960 synchronized(this) { 15961 if (!(token instanceof ServiceRecord)) { 15962 Slog.e(TAG, "serviceDoneExecuting: Invalid service token=" + token); 15963 throw new IllegalArgumentException("Invalid service token"); 15964 } 15965 mServices.serviceDoneExecutingLocked((ServiceRecord)token, type, startId, res); 15966 } 15967 } 15968 15969 // ========================================================= 15970 // BACKUP AND RESTORE 15971 // ========================================================= 15972 15973 // Cause the target app to be launched if necessary and its backup agent 15974 // instantiated. The backup agent will invoke backupAgentCreated() on the 15975 // activity manager to announce its creation. 15976 public boolean bindBackupAgent(ApplicationInfo app, int backupMode) { 15977 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, 15978 "bindBackupAgent: app=" + app + " mode=" + backupMode); 15979 enforceCallingPermission("android.permission.CONFIRM_FULL_BACKUP", "bindBackupAgent"); 15980 15981 synchronized(this) { 15982 // !!! TODO: currently no check here that we're already bound 15983 BatteryStatsImpl.Uid.Pkg.Serv ss = null; 15984 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 15985 synchronized (stats) { 15986 ss = stats.getServiceStatsLocked(app.uid, app.packageName, app.name); 15987 } 15988 15989 // Backup agent is now in use, its package can't be stopped. 15990 try { 15991 AppGlobals.getPackageManager().setPackageStoppedState( 15992 app.packageName, false, UserHandle.getUserId(app.uid)); 15993 } catch (RemoteException e) { 15994 } catch (IllegalArgumentException e) { 15995 Slog.w(TAG, "Failed trying to unstop package " 15996 + app.packageName + ": " + e); 15997 } 15998 15999 BackupRecord r = new BackupRecord(ss, app, backupMode); 16000 ComponentName hostingName = (backupMode == IApplicationThread.BACKUP_MODE_INCREMENTAL) 16001 ? new ComponentName(app.packageName, app.backupAgentName) 16002 : new ComponentName("android", "FullBackupAgent"); 16003 // startProcessLocked() returns existing proc's record if it's already running 16004 ProcessRecord proc = startProcessLocked(app.processName, app, 16005 false, 0, "backup", hostingName, false, false, false); 16006 if (proc == null) { 16007 Slog.e(TAG, "Unable to start backup agent process " + r); 16008 return false; 16009 } 16010 16011 r.app = proc; 16012 mBackupTarget = r; 16013 mBackupAppName = app.packageName; 16014 16015 // Try not to kill the process during backup 16016 updateOomAdjLocked(proc); 16017 16018 // If the process is already attached, schedule the creation of the backup agent now. 16019 // If it is not yet live, this will be done when it attaches to the framework. 16020 if (proc.thread != null) { 16021 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "Agent proc already running: " + proc); 16022 try { 16023 proc.thread.scheduleCreateBackupAgent(app, 16024 compatibilityInfoForPackageLocked(app), backupMode); 16025 } catch (RemoteException e) { 16026 // Will time out on the backup manager side 16027 } 16028 } else { 16029 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "Agent proc not running, waiting for attach"); 16030 } 16031 // Invariants: at this point, the target app process exists and the application 16032 // is either already running or in the process of coming up. mBackupTarget and 16033 // mBackupAppName describe the app, so that when it binds back to the AM we 16034 // know that it's scheduled for a backup-agent operation. 16035 } 16036 16037 return true; 16038 } 16039 16040 @Override 16041 public void clearPendingBackup() { 16042 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "clearPendingBackup"); 16043 enforceCallingPermission("android.permission.BACKUP", "clearPendingBackup"); 16044 16045 synchronized (this) { 16046 mBackupTarget = null; 16047 mBackupAppName = null; 16048 } 16049 } 16050 16051 // A backup agent has just come up 16052 public void backupAgentCreated(String agentPackageName, IBinder agent) { 16053 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "backupAgentCreated: " + agentPackageName 16054 + " = " + agent); 16055 16056 synchronized(this) { 16057 if (!agentPackageName.equals(mBackupAppName)) { 16058 Slog.e(TAG, "Backup agent created for " + agentPackageName + " but not requested!"); 16059 return; 16060 } 16061 } 16062 16063 long oldIdent = Binder.clearCallingIdentity(); 16064 try { 16065 IBackupManager bm = IBackupManager.Stub.asInterface( 16066 ServiceManager.getService(Context.BACKUP_SERVICE)); 16067 bm.agentConnected(agentPackageName, agent); 16068 } catch (RemoteException e) { 16069 // can't happen; the backup manager service is local 16070 } catch (Exception e) { 16071 Slog.w(TAG, "Exception trying to deliver BackupAgent binding: "); 16072 e.printStackTrace(); 16073 } finally { 16074 Binder.restoreCallingIdentity(oldIdent); 16075 } 16076 } 16077 16078 // done with this agent 16079 public void unbindBackupAgent(ApplicationInfo appInfo) { 16080 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "unbindBackupAgent: " + appInfo); 16081 if (appInfo == null) { 16082 Slog.w(TAG, "unbind backup agent for null app"); 16083 return; 16084 } 16085 16086 synchronized(this) { 16087 try { 16088 if (mBackupAppName == null) { 16089 Slog.w(TAG, "Unbinding backup agent with no active backup"); 16090 return; 16091 } 16092 16093 if (!mBackupAppName.equals(appInfo.packageName)) { 16094 Slog.e(TAG, "Unbind of " + appInfo + " but is not the current backup target"); 16095 return; 16096 } 16097 16098 // Not backing this app up any more; reset its OOM adjustment 16099 final ProcessRecord proc = mBackupTarget.app; 16100 updateOomAdjLocked(proc); 16101 16102 // If the app crashed during backup, 'thread' will be null here 16103 if (proc.thread != null) { 16104 try { 16105 proc.thread.scheduleDestroyBackupAgent(appInfo, 16106 compatibilityInfoForPackageLocked(appInfo)); 16107 } catch (Exception e) { 16108 Slog.e(TAG, "Exception when unbinding backup agent:"); 16109 e.printStackTrace(); 16110 } 16111 } 16112 } finally { 16113 mBackupTarget = null; 16114 mBackupAppName = null; 16115 } 16116 } 16117 } 16118 // ========================================================= 16119 // BROADCASTS 16120 // ========================================================= 16121 16122 boolean isPendingBroadcastProcessLocked(int pid) { 16123 return mFgBroadcastQueue.isPendingBroadcastProcessLocked(pid) 16124 || mBgBroadcastQueue.isPendingBroadcastProcessLocked(pid); 16125 } 16126 16127 void skipPendingBroadcastLocked(int pid) { 16128 Slog.w(TAG, "Unattached app died before broadcast acknowledged, skipping"); 16129 for (BroadcastQueue queue : mBroadcastQueues) { 16130 queue.skipPendingBroadcastLocked(pid); 16131 } 16132 } 16133 16134 // The app just attached; send any pending broadcasts that it should receive 16135 boolean sendPendingBroadcastsLocked(ProcessRecord app) { 16136 boolean didSomething = false; 16137 for (BroadcastQueue queue : mBroadcastQueues) { 16138 didSomething |= queue.sendPendingBroadcastsLocked(app); 16139 } 16140 return didSomething; 16141 } 16142 16143 public Intent registerReceiver(IApplicationThread caller, String callerPackage, 16144 IIntentReceiver receiver, IntentFilter filter, String permission, int userId) { 16145 enforceNotIsolatedCaller("registerReceiver"); 16146 ArrayList<Intent> stickyIntents = null; 16147 ProcessRecord callerApp = null; 16148 int callingUid; 16149 int callingPid; 16150 synchronized(this) { 16151 if (caller != null) { 16152 callerApp = getRecordForAppLocked(caller); 16153 if (callerApp == null) { 16154 throw new SecurityException( 16155 "Unable to find app for caller " + caller 16156 + " (pid=" + Binder.getCallingPid() 16157 + ") when registering receiver " + receiver); 16158 } 16159 if (callerApp.info.uid != Process.SYSTEM_UID && 16160 !callerApp.pkgList.containsKey(callerPackage) && 16161 !"android".equals(callerPackage)) { 16162 throw new SecurityException("Given caller package " + callerPackage 16163 + " is not running in process " + callerApp); 16164 } 16165 callingUid = callerApp.info.uid; 16166 callingPid = callerApp.pid; 16167 } else { 16168 callerPackage = null; 16169 callingUid = Binder.getCallingUid(); 16170 callingPid = Binder.getCallingPid(); 16171 } 16172 16173 userId = handleIncomingUser(callingPid, callingUid, userId, 16174 true, ALLOW_FULL_ONLY, "registerReceiver", callerPackage); 16175 16176 Iterator<String> actions = filter.actionsIterator(); 16177 if (actions == null) { 16178 ArrayList<String> noAction = new ArrayList<String>(1); 16179 noAction.add(null); 16180 actions = noAction.iterator(); 16181 } 16182 16183 // Collect stickies of users 16184 int[] userIds = { UserHandle.USER_ALL, UserHandle.getUserId(callingUid) }; 16185 while (actions.hasNext()) { 16186 String action = actions.next(); 16187 for (int id : userIds) { 16188 ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(id); 16189 if (stickies != null) { 16190 ArrayList<Intent> intents = stickies.get(action); 16191 if (intents != null) { 16192 if (stickyIntents == null) { 16193 stickyIntents = new ArrayList<Intent>(); 16194 } 16195 stickyIntents.addAll(intents); 16196 } 16197 } 16198 } 16199 } 16200 } 16201 16202 ArrayList<Intent> allSticky = null; 16203 if (stickyIntents != null) { 16204 final ContentResolver resolver = mContext.getContentResolver(); 16205 // Look for any matching sticky broadcasts... 16206 for (int i = 0, N = stickyIntents.size(); i < N; i++) { 16207 Intent intent = stickyIntents.get(i); 16208 // If intent has scheme "content", it will need to acccess 16209 // provider that needs to lock mProviderMap in ActivityThread 16210 // and also it may need to wait application response, so we 16211 // cannot lock ActivityManagerService here. 16212 if (filter.match(resolver, intent, true, TAG) >= 0) { 16213 if (allSticky == null) { 16214 allSticky = new ArrayList<Intent>(); 16215 } 16216 allSticky.add(intent); 16217 } 16218 } 16219 } 16220 16221 // The first sticky in the list is returned directly back to the client. 16222 Intent sticky = allSticky != null ? allSticky.get(0) : null; 16223 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Register receiver " + filter + ": " + sticky); 16224 if (receiver == null) { 16225 return sticky; 16226 } 16227 16228 synchronized (this) { 16229 if (callerApp != null && (callerApp.thread == null 16230 || callerApp.thread.asBinder() != caller.asBinder())) { 16231 // Original caller already died 16232 return null; 16233 } 16234 ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder()); 16235 if (rl == null) { 16236 rl = new ReceiverList(this, callerApp, callingPid, callingUid, 16237 userId, receiver); 16238 if (rl.app != null) { 16239 rl.app.receivers.add(rl); 16240 } else { 16241 try { 16242 receiver.asBinder().linkToDeath(rl, 0); 16243 } catch (RemoteException e) { 16244 return sticky; 16245 } 16246 rl.linkedToDeath = true; 16247 } 16248 mRegisteredReceivers.put(receiver.asBinder(), rl); 16249 } else if (rl.uid != callingUid) { 16250 throw new IllegalArgumentException( 16251 "Receiver requested to register for uid " + callingUid 16252 + " was previously registered for uid " + rl.uid); 16253 } else if (rl.pid != callingPid) { 16254 throw new IllegalArgumentException( 16255 "Receiver requested to register for pid " + callingPid 16256 + " was previously registered for pid " + rl.pid); 16257 } else if (rl.userId != userId) { 16258 throw new IllegalArgumentException( 16259 "Receiver requested to register for user " + userId 16260 + " was previously registered for user " + rl.userId); 16261 } 16262 BroadcastFilter bf = new BroadcastFilter(filter, rl, callerPackage, 16263 permission, callingUid, userId); 16264 rl.add(bf); 16265 if (!bf.debugCheck()) { 16266 Slog.w(TAG, "==> For Dynamic broadcast"); 16267 } 16268 mReceiverResolver.addFilter(bf); 16269 16270 // Enqueue broadcasts for all existing stickies that match 16271 // this filter. 16272 if (allSticky != null) { 16273 ArrayList receivers = new ArrayList(); 16274 receivers.add(bf); 16275 16276 final int stickyCount = allSticky.size(); 16277 for (int i = 0; i < stickyCount; i++) { 16278 Intent intent = allSticky.get(i); 16279 BroadcastQueue queue = broadcastQueueForIntent(intent); 16280 BroadcastRecord r = new BroadcastRecord(queue, intent, null, 16281 null, -1, -1, null, null, AppOpsManager.OP_NONE, null, receivers, 16282 null, 0, null, null, false, true, true, -1); 16283 queue.enqueueParallelBroadcastLocked(r); 16284 queue.scheduleBroadcastsLocked(); 16285 } 16286 } 16287 16288 return sticky; 16289 } 16290 } 16291 16292 public void unregisterReceiver(IIntentReceiver receiver) { 16293 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Unregister receiver: " + receiver); 16294 16295 final long origId = Binder.clearCallingIdentity(); 16296 try { 16297 boolean doTrim = false; 16298 16299 synchronized(this) { 16300 ReceiverList rl = mRegisteredReceivers.get(receiver.asBinder()); 16301 if (rl != null) { 16302 final BroadcastRecord r = rl.curBroadcast; 16303 if (r != null && r == r.queue.getMatchingOrderedReceiver(r)) { 16304 final boolean doNext = r.queue.finishReceiverLocked( 16305 r, r.resultCode, r.resultData, r.resultExtras, 16306 r.resultAbort, false); 16307 if (doNext) { 16308 doTrim = true; 16309 r.queue.processNextBroadcast(false); 16310 } 16311 } 16312 16313 if (rl.app != null) { 16314 rl.app.receivers.remove(rl); 16315 } 16316 removeReceiverLocked(rl); 16317 if (rl.linkedToDeath) { 16318 rl.linkedToDeath = false; 16319 rl.receiver.asBinder().unlinkToDeath(rl, 0); 16320 } 16321 } 16322 } 16323 16324 // If we actually concluded any broadcasts, we might now be able 16325 // to trim the recipients' apps from our working set 16326 if (doTrim) { 16327 trimApplications(); 16328 return; 16329 } 16330 16331 } finally { 16332 Binder.restoreCallingIdentity(origId); 16333 } 16334 } 16335 16336 void removeReceiverLocked(ReceiverList rl) { 16337 mRegisteredReceivers.remove(rl.receiver.asBinder()); 16338 for (int i = rl.size() - 1; i >= 0; i--) { 16339 mReceiverResolver.removeFilter(rl.get(i)); 16340 } 16341 } 16342 16343 private final void sendPackageBroadcastLocked(int cmd, String[] packages, int userId) { 16344 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 16345 ProcessRecord r = mLruProcesses.get(i); 16346 if (r.thread != null && (userId == UserHandle.USER_ALL || r.userId == userId)) { 16347 try { 16348 r.thread.dispatchPackageBroadcast(cmd, packages); 16349 } catch (RemoteException ex) { 16350 } 16351 } 16352 } 16353 } 16354 16355 private List<ResolveInfo> collectReceiverComponents(Intent intent, String resolvedType, 16356 int callingUid, int[] users) { 16357 List<ResolveInfo> receivers = null; 16358 try { 16359 HashSet<ComponentName> singleUserReceivers = null; 16360 boolean scannedFirstReceivers = false; 16361 for (int user : users) { 16362 // Skip users that have Shell restrictions 16363 if (callingUid == Process.SHELL_UID 16364 && getUserManagerLocked().hasUserRestriction( 16365 UserManager.DISALLOW_DEBUGGING_FEATURES, user)) { 16366 continue; 16367 } 16368 List<ResolveInfo> newReceivers = AppGlobals.getPackageManager() 16369 .queryIntentReceivers(intent, resolvedType, STOCK_PM_FLAGS, user); 16370 if (user != UserHandle.USER_OWNER && newReceivers != null) { 16371 // If this is not the primary user, we need to check for 16372 // any receivers that should be filtered out. 16373 for (int i=0; i<newReceivers.size(); i++) { 16374 ResolveInfo ri = newReceivers.get(i); 16375 if ((ri.activityInfo.flags&ActivityInfo.FLAG_PRIMARY_USER_ONLY) != 0) { 16376 newReceivers.remove(i); 16377 i--; 16378 } 16379 } 16380 } 16381 if (newReceivers != null && newReceivers.size() == 0) { 16382 newReceivers = null; 16383 } 16384 if (receivers == null) { 16385 receivers = newReceivers; 16386 } else if (newReceivers != null) { 16387 // We need to concatenate the additional receivers 16388 // found with what we have do far. This would be easy, 16389 // but we also need to de-dup any receivers that are 16390 // singleUser. 16391 if (!scannedFirstReceivers) { 16392 // Collect any single user receivers we had already retrieved. 16393 scannedFirstReceivers = true; 16394 for (int i=0; i<receivers.size(); i++) { 16395 ResolveInfo ri = receivers.get(i); 16396 if ((ri.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) { 16397 ComponentName cn = new ComponentName( 16398 ri.activityInfo.packageName, ri.activityInfo.name); 16399 if (singleUserReceivers == null) { 16400 singleUserReceivers = new HashSet<ComponentName>(); 16401 } 16402 singleUserReceivers.add(cn); 16403 } 16404 } 16405 } 16406 // Add the new results to the existing results, tracking 16407 // and de-dupping single user receivers. 16408 for (int i=0; i<newReceivers.size(); i++) { 16409 ResolveInfo ri = newReceivers.get(i); 16410 if ((ri.activityInfo.flags&ActivityInfo.FLAG_SINGLE_USER) != 0) { 16411 ComponentName cn = new ComponentName( 16412 ri.activityInfo.packageName, ri.activityInfo.name); 16413 if (singleUserReceivers == null) { 16414 singleUserReceivers = new HashSet<ComponentName>(); 16415 } 16416 if (!singleUserReceivers.contains(cn)) { 16417 singleUserReceivers.add(cn); 16418 receivers.add(ri); 16419 } 16420 } else { 16421 receivers.add(ri); 16422 } 16423 } 16424 } 16425 } 16426 } catch (RemoteException ex) { 16427 // pm is in same process, this will never happen. 16428 } 16429 return receivers; 16430 } 16431 16432 private final int broadcastIntentLocked(ProcessRecord callerApp, 16433 String callerPackage, Intent intent, String resolvedType, 16434 IIntentReceiver resultTo, int resultCode, String resultData, 16435 Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle options, 16436 boolean ordered, boolean sticky, int callingPid, int callingUid, int userId) { 16437 intent = new Intent(intent); 16438 16439 // By default broadcasts do not go to stopped apps. 16440 intent.addFlags(Intent.FLAG_EXCLUDE_STOPPED_PACKAGES); 16441 16442 // If we have not finished booting, don't allow this to launch new processes. 16443 if (!mProcessesReady && (intent.getFlags()&Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) { 16444 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 16445 } 16446 16447 if (DEBUG_BROADCAST_LIGHT) Slog.v(TAG_BROADCAST, 16448 (sticky ? "Broadcast sticky: ": "Broadcast: ") + intent 16449 + " ordered=" + ordered + " userid=" + userId); 16450 if ((resultTo != null) && !ordered) { 16451 Slog.w(TAG, "Broadcast " + intent + " not ordered but result callback requested!"); 16452 } 16453 16454 userId = handleIncomingUser(callingPid, callingUid, userId, 16455 true, ALLOW_NON_FULL, "broadcast", callerPackage); 16456 16457 // Make sure that the user who is receiving this broadcast is running. 16458 // If not, we will just skip it. Make an exception for shutdown broadcasts 16459 // and upgrade steps. 16460 16461 if (userId != UserHandle.USER_ALL && !isUserRunningLocked(userId, false)) { 16462 if ((callingUid != Process.SYSTEM_UID 16463 || (intent.getFlags() & Intent.FLAG_RECEIVER_BOOT_UPGRADE) == 0) 16464 && !Intent.ACTION_SHUTDOWN.equals(intent.getAction())) { 16465 Slog.w(TAG, "Skipping broadcast of " + intent 16466 + ": user " + userId + " is stopped"); 16467 return ActivityManager.BROADCAST_FAILED_USER_STOPPED; 16468 } 16469 } 16470 16471 BroadcastOptions brOptions = null; 16472 if (options != null) { 16473 brOptions = new BroadcastOptions(options); 16474 if (brOptions.getTemporaryAppWhitelistDuration() > 0) { 16475 // See if the caller is allowed to do this. Note we are checking against 16476 // the actual real caller (not whoever provided the operation as say a 16477 // PendingIntent), because that who is actually supplied the arguments. 16478 if (checkComponentPermission( 16479 android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST, 16480 Binder.getCallingPid(), Binder.getCallingUid(), -1, true) 16481 != PackageManager.PERMISSION_GRANTED) { 16482 String msg = "Permission Denial: " + intent.getAction() 16483 + " broadcast from " + callerPackage + " (pid=" + callingPid 16484 + ", uid=" + callingUid + ")" 16485 + " requires " 16486 + android.Manifest.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST; 16487 Slog.w(TAG, msg); 16488 throw new SecurityException(msg); 16489 } 16490 } 16491 } 16492 16493 /* 16494 * Prevent non-system code (defined here to be non-persistent 16495 * processes) from sending protected broadcasts. 16496 */ 16497 int callingAppId = UserHandle.getAppId(callingUid); 16498 if (callingAppId == Process.SYSTEM_UID || callingAppId == Process.PHONE_UID 16499 || callingAppId == Process.SHELL_UID || callingAppId == Process.BLUETOOTH_UID 16500 || callingAppId == Process.NFC_UID || callingUid == 0) { 16501 // Always okay. 16502 } else if (callerApp == null || !callerApp.persistent) { 16503 try { 16504 if (AppGlobals.getPackageManager().isProtectedBroadcast( 16505 intent.getAction())) { 16506 String msg = "Permission Denial: not allowed to send broadcast " 16507 + intent.getAction() + " from pid=" 16508 + callingPid + ", uid=" + callingUid; 16509 Slog.w(TAG, msg); 16510 throw new SecurityException(msg); 16511 } else if (AppWidgetManager.ACTION_APPWIDGET_CONFIGURE.equals(intent.getAction())) { 16512 // Special case for compatibility: we don't want apps to send this, 16513 // but historically it has not been protected and apps may be using it 16514 // to poke their own app widget. So, instead of making it protected, 16515 // just limit it to the caller. 16516 if (callerApp == null) { 16517 String msg = "Permission Denial: not allowed to send broadcast " 16518 + intent.getAction() + " from unknown caller."; 16519 Slog.w(TAG, msg); 16520 throw new SecurityException(msg); 16521 } else if (intent.getComponent() != null) { 16522 // They are good enough to send to an explicit component... verify 16523 // it is being sent to the calling app. 16524 if (!intent.getComponent().getPackageName().equals( 16525 callerApp.info.packageName)) { 16526 String msg = "Permission Denial: not allowed to send broadcast " 16527 + intent.getAction() + " to " 16528 + intent.getComponent().getPackageName() + " from " 16529 + callerApp.info.packageName; 16530 Slog.w(TAG, msg); 16531 throw new SecurityException(msg); 16532 } 16533 } else { 16534 // Limit broadcast to their own package. 16535 intent.setPackage(callerApp.info.packageName); 16536 } 16537 } 16538 } catch (RemoteException e) { 16539 Slog.w(TAG, "Remote exception", e); 16540 return ActivityManager.BROADCAST_SUCCESS; 16541 } 16542 } 16543 16544 final String action = intent.getAction(); 16545 if (action != null) { 16546 switch (action) { 16547 case Intent.ACTION_UID_REMOVED: 16548 case Intent.ACTION_PACKAGE_REMOVED: 16549 case Intent.ACTION_PACKAGE_CHANGED: 16550 case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE: 16551 case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE: 16552 // Handle special intents: if this broadcast is from the package 16553 // manager about a package being removed, we need to remove all of 16554 // its activities from the history stack. 16555 if (checkComponentPermission( 16556 android.Manifest.permission.BROADCAST_PACKAGE_REMOVED, 16557 callingPid, callingUid, -1, true) 16558 != PackageManager.PERMISSION_GRANTED) { 16559 String msg = "Permission Denial: " + intent.getAction() 16560 + " broadcast from " + callerPackage + " (pid=" + callingPid 16561 + ", uid=" + callingUid + ")" 16562 + " requires " 16563 + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED; 16564 Slog.w(TAG, msg); 16565 throw new SecurityException(msg); 16566 } 16567 switch (action) { 16568 case Intent.ACTION_UID_REMOVED: 16569 final Bundle intentExtras = intent.getExtras(); 16570 final int uid = intentExtras != null 16571 ? intentExtras.getInt(Intent.EXTRA_UID) : -1; 16572 if (uid >= 0) { 16573 mBatteryStatsService.removeUid(uid); 16574 mAppOpsService.uidRemoved(uid); 16575 } 16576 break; 16577 case Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE: 16578 // If resources are unavailable just force stop all those packages 16579 // and flush the attribute cache as well. 16580 String list[] = 16581 intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 16582 if (list != null && list.length > 0) { 16583 for (int i = 0; i < list.length; i++) { 16584 forceStopPackageLocked(list[i], -1, false, true, true, 16585 false, false, userId, "storage unmount"); 16586 } 16587 mRecentTasks.cleanupLocked(UserHandle.USER_ALL); 16588 sendPackageBroadcastLocked( 16589 IApplicationThread.EXTERNAL_STORAGE_UNAVAILABLE, list, 16590 userId); 16591 } 16592 break; 16593 case Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE: 16594 mRecentTasks.cleanupLocked(UserHandle.USER_ALL); 16595 break; 16596 case Intent.ACTION_PACKAGE_REMOVED: 16597 case Intent.ACTION_PACKAGE_CHANGED: 16598 Uri data = intent.getData(); 16599 String ssp; 16600 if (data != null && (ssp=data.getSchemeSpecificPart()) != null) { 16601 boolean removed = Intent.ACTION_PACKAGE_REMOVED.equals(action); 16602 boolean fullUninstall = removed && 16603 !intent.getBooleanExtra(Intent.EXTRA_REPLACING, false); 16604 if (!intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP, false)) { 16605 forceStopPackageLocked(ssp, UserHandle.getAppId( 16606 intent.getIntExtra(Intent.EXTRA_UID, -1)), 16607 false, true, true, false, fullUninstall, userId, 16608 removed ? "pkg removed" : "pkg changed"); 16609 } 16610 if (removed) { 16611 sendPackageBroadcastLocked(IApplicationThread.PACKAGE_REMOVED, 16612 new String[] {ssp}, userId); 16613 if (fullUninstall) { 16614 mAppOpsService.packageRemoved( 16615 intent.getIntExtra(Intent.EXTRA_UID, -1), ssp); 16616 16617 // Remove all permissions granted from/to this package 16618 removeUriPermissionsForPackageLocked(ssp, userId, true); 16619 16620 removeTasksByPackageNameLocked(ssp, userId); 16621 mBatteryStatsService.notePackageUninstalled(ssp); 16622 } 16623 } else { 16624 cleanupDisabledPackageComponentsLocked(ssp, userId, 16625 intent.getStringArrayExtra( 16626 Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST)); 16627 } 16628 } 16629 break; 16630 } 16631 break; 16632 case Intent.ACTION_PACKAGE_ADDED: 16633 // Special case for adding a package: by default turn on compatibility mode. 16634 Uri data = intent.getData(); 16635 String ssp; 16636 if (data != null && (ssp = data.getSchemeSpecificPart()) != null) { 16637 final boolean replacing = 16638 intent.getBooleanExtra(Intent.EXTRA_REPLACING, false); 16639 mCompatModePackages.handlePackageAddedLocked(ssp, replacing); 16640 16641 try { 16642 ApplicationInfo ai = AppGlobals.getPackageManager(). 16643 getApplicationInfo(ssp, 0, 0); 16644 mBatteryStatsService.notePackageInstalled(ssp, 16645 ai != null ? ai.versionCode : 0); 16646 } catch (RemoteException e) { 16647 } 16648 } 16649 break; 16650 case Intent.ACTION_TIMEZONE_CHANGED: 16651 // If this is the time zone changed action, queue up a message that will reset 16652 // the timezone of all currently running processes. This message will get 16653 // queued up before the broadcast happens. 16654 mHandler.sendEmptyMessage(UPDATE_TIME_ZONE); 16655 break; 16656 case Intent.ACTION_TIME_CHANGED: 16657 // If the user set the time, let all running processes know. 16658 final int is24Hour = 16659 intent.getBooleanExtra(Intent.EXTRA_TIME_PREF_24_HOUR_FORMAT, false) ? 1 16660 : 0; 16661 mHandler.sendMessage(mHandler.obtainMessage(UPDATE_TIME, is24Hour, 0)); 16662 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 16663 synchronized (stats) { 16664 stats.noteCurrentTimeChangedLocked(); 16665 } 16666 break; 16667 case Intent.ACTION_CLEAR_DNS_CACHE: 16668 mHandler.sendEmptyMessage(CLEAR_DNS_CACHE_MSG); 16669 break; 16670 case Proxy.PROXY_CHANGE_ACTION: 16671 ProxyInfo proxy = intent.getParcelableExtra(Proxy.EXTRA_PROXY_INFO); 16672 mHandler.sendMessage(mHandler.obtainMessage(UPDATE_HTTP_PROXY_MSG, proxy)); 16673 break; 16674 } 16675 } 16676 16677 // Add to the sticky list if requested. 16678 if (sticky) { 16679 if (checkPermission(android.Manifest.permission.BROADCAST_STICKY, 16680 callingPid, callingUid) 16681 != PackageManager.PERMISSION_GRANTED) { 16682 String msg = "Permission Denial: broadcastIntent() requesting a sticky broadcast from pid=" 16683 + callingPid + ", uid=" + callingUid 16684 + " requires " + android.Manifest.permission.BROADCAST_STICKY; 16685 Slog.w(TAG, msg); 16686 throw new SecurityException(msg); 16687 } 16688 if (requiredPermissions != null && requiredPermissions.length > 0) { 16689 Slog.w(TAG, "Can't broadcast sticky intent " + intent 16690 + " and enforce permissions " + Arrays.toString(requiredPermissions)); 16691 return ActivityManager.BROADCAST_STICKY_CANT_HAVE_PERMISSION; 16692 } 16693 if (intent.getComponent() != null) { 16694 throw new SecurityException( 16695 "Sticky broadcasts can't target a specific component"); 16696 } 16697 // We use userId directly here, since the "all" target is maintained 16698 // as a separate set of sticky broadcasts. 16699 if (userId != UserHandle.USER_ALL) { 16700 // But first, if this is not a broadcast to all users, then 16701 // make sure it doesn't conflict with an existing broadcast to 16702 // all users. 16703 ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get( 16704 UserHandle.USER_ALL); 16705 if (stickies != null) { 16706 ArrayList<Intent> list = stickies.get(intent.getAction()); 16707 if (list != null) { 16708 int N = list.size(); 16709 int i; 16710 for (i=0; i<N; i++) { 16711 if (intent.filterEquals(list.get(i))) { 16712 throw new IllegalArgumentException( 16713 "Sticky broadcast " + intent + " for user " 16714 + userId + " conflicts with existing global broadcast"); 16715 } 16716 } 16717 } 16718 } 16719 } 16720 ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId); 16721 if (stickies == null) { 16722 stickies = new ArrayMap<>(); 16723 mStickyBroadcasts.put(userId, stickies); 16724 } 16725 ArrayList<Intent> list = stickies.get(intent.getAction()); 16726 if (list == null) { 16727 list = new ArrayList<>(); 16728 stickies.put(intent.getAction(), list); 16729 } 16730 final int stickiesCount = list.size(); 16731 int i; 16732 for (i = 0; i < stickiesCount; i++) { 16733 if (intent.filterEquals(list.get(i))) { 16734 // This sticky already exists, replace it. 16735 list.set(i, new Intent(intent)); 16736 break; 16737 } 16738 } 16739 if (i >= stickiesCount) { 16740 list.add(new Intent(intent)); 16741 } 16742 } 16743 16744 int[] users; 16745 if (userId == UserHandle.USER_ALL) { 16746 // Caller wants broadcast to go to all started users. 16747 users = mStartedUserArray; 16748 } else { 16749 // Caller wants broadcast to go to one specific user. 16750 users = new int[] {userId}; 16751 } 16752 16753 // Figure out who all will receive this broadcast. 16754 List receivers = null; 16755 List<BroadcastFilter> registeredReceivers = null; 16756 // Need to resolve the intent to interested receivers... 16757 if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) 16758 == 0) { 16759 receivers = collectReceiverComponents(intent, resolvedType, callingUid, users); 16760 } 16761 if (intent.getComponent() == null) { 16762 if (userId == UserHandle.USER_ALL && callingUid == Process.SHELL_UID) { 16763 // Query one target user at a time, excluding shell-restricted users 16764 UserManagerService ums = getUserManagerLocked(); 16765 for (int i = 0; i < users.length; i++) { 16766 if (ums.hasUserRestriction( 16767 UserManager.DISALLOW_DEBUGGING_FEATURES, users[i])) { 16768 continue; 16769 } 16770 List<BroadcastFilter> registeredReceiversForUser = 16771 mReceiverResolver.queryIntent(intent, 16772 resolvedType, false, users[i]); 16773 if (registeredReceivers == null) { 16774 registeredReceivers = registeredReceiversForUser; 16775 } else if (registeredReceiversForUser != null) { 16776 registeredReceivers.addAll(registeredReceiversForUser); 16777 } 16778 } 16779 } else { 16780 registeredReceivers = mReceiverResolver.queryIntent(intent, 16781 resolvedType, false, userId); 16782 } 16783 } 16784 16785 final boolean replacePending = 16786 (intent.getFlags()&Intent.FLAG_RECEIVER_REPLACE_PENDING) != 0; 16787 16788 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueing broadcast: " + intent.getAction() 16789 + " replacePending=" + replacePending); 16790 16791 int NR = registeredReceivers != null ? registeredReceivers.size() : 0; 16792 if (!ordered && NR > 0) { 16793 // If we are not serializing this broadcast, then send the 16794 // registered receivers separately so they don't wait for the 16795 // components to be launched. 16796 final BroadcastQueue queue = broadcastQueueForIntent(intent); 16797 BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, 16798 callerPackage, callingPid, callingUid, resolvedType, requiredPermissions, 16799 appOp, brOptions, registeredReceivers, resultTo, resultCode, resultData, 16800 resultExtras, ordered, sticky, false, userId); 16801 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing parallel broadcast " + r); 16802 final boolean replaced = replacePending && queue.replaceParallelBroadcastLocked(r); 16803 if (!replaced) { 16804 queue.enqueueParallelBroadcastLocked(r); 16805 queue.scheduleBroadcastsLocked(); 16806 } 16807 registeredReceivers = null; 16808 NR = 0; 16809 } 16810 16811 // Merge into one list. 16812 int ir = 0; 16813 if (receivers != null) { 16814 // A special case for PACKAGE_ADDED: do not allow the package 16815 // being added to see this broadcast. This prevents them from 16816 // using this as a back door to get run as soon as they are 16817 // installed. Maybe in the future we want to have a special install 16818 // broadcast or such for apps, but we'd like to deliberately make 16819 // this decision. 16820 String skipPackages[] = null; 16821 if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction()) 16822 || Intent.ACTION_PACKAGE_RESTARTED.equals(intent.getAction()) 16823 || Intent.ACTION_PACKAGE_DATA_CLEARED.equals(intent.getAction())) { 16824 Uri data = intent.getData(); 16825 if (data != null) { 16826 String pkgName = data.getSchemeSpecificPart(); 16827 if (pkgName != null) { 16828 skipPackages = new String[] { pkgName }; 16829 } 16830 } 16831 } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(intent.getAction())) { 16832 skipPackages = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST); 16833 } 16834 if (skipPackages != null && (skipPackages.length > 0)) { 16835 for (String skipPackage : skipPackages) { 16836 if (skipPackage != null) { 16837 int NT = receivers.size(); 16838 for (int it=0; it<NT; it++) { 16839 ResolveInfo curt = (ResolveInfo)receivers.get(it); 16840 if (curt.activityInfo.packageName.equals(skipPackage)) { 16841 receivers.remove(it); 16842 it--; 16843 NT--; 16844 } 16845 } 16846 } 16847 } 16848 } 16849 16850 int NT = receivers != null ? receivers.size() : 0; 16851 int it = 0; 16852 ResolveInfo curt = null; 16853 BroadcastFilter curr = null; 16854 while (it < NT && ir < NR) { 16855 if (curt == null) { 16856 curt = (ResolveInfo)receivers.get(it); 16857 } 16858 if (curr == null) { 16859 curr = registeredReceivers.get(ir); 16860 } 16861 if (curr.getPriority() >= curt.priority) { 16862 // Insert this broadcast record into the final list. 16863 receivers.add(it, curr); 16864 ir++; 16865 curr = null; 16866 it++; 16867 NT++; 16868 } else { 16869 // Skip to the next ResolveInfo in the final list. 16870 it++; 16871 curt = null; 16872 } 16873 } 16874 } 16875 while (ir < NR) { 16876 if (receivers == null) { 16877 receivers = new ArrayList(); 16878 } 16879 receivers.add(registeredReceivers.get(ir)); 16880 ir++; 16881 } 16882 16883 if ((receivers != null && receivers.size() > 0) 16884 || resultTo != null) { 16885 BroadcastQueue queue = broadcastQueueForIntent(intent); 16886 BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, 16887 callerPackage, callingPid, callingUid, resolvedType, 16888 requiredPermissions, appOp, brOptions, receivers, resultTo, resultCode, 16889 resultData, resultExtras, ordered, sticky, false, userId); 16890 16891 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Enqueueing ordered broadcast " + r 16892 + ": prev had " + queue.mOrderedBroadcasts.size()); 16893 if (DEBUG_BROADCAST) Slog.i(TAG_BROADCAST, 16894 "Enqueueing broadcast " + r.intent.getAction()); 16895 16896 boolean replaced = replacePending && queue.replaceOrderedBroadcastLocked(r); 16897 if (!replaced) { 16898 queue.enqueueOrderedBroadcastLocked(r); 16899 queue.scheduleBroadcastsLocked(); 16900 } 16901 } 16902 16903 return ActivityManager.BROADCAST_SUCCESS; 16904 } 16905 16906 final Intent verifyBroadcastLocked(Intent intent) { 16907 // Refuse possible leaked file descriptors 16908 if (intent != null && intent.hasFileDescriptors() == true) { 16909 throw new IllegalArgumentException("File descriptors passed in Intent"); 16910 } 16911 16912 int flags = intent.getFlags(); 16913 16914 if (!mProcessesReady) { 16915 // if the caller really truly claims to know what they're doing, go 16916 // ahead and allow the broadcast without launching any receivers 16917 if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT) != 0) { 16918 // This will be turned into a FLAG_RECEIVER_REGISTERED_ONLY later on if needed. 16919 } else if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0) { 16920 Slog.e(TAG, "Attempt to launch receivers of broadcast intent " + intent 16921 + " before boot completion"); 16922 throw new IllegalStateException("Cannot broadcast before boot completed"); 16923 } 16924 } 16925 16926 if ((flags&Intent.FLAG_RECEIVER_BOOT_UPGRADE) != 0) { 16927 throw new IllegalArgumentException( 16928 "Can't use FLAG_RECEIVER_BOOT_UPGRADE here"); 16929 } 16930 16931 return intent; 16932 } 16933 16934 public final int broadcastIntent(IApplicationThread caller, 16935 Intent intent, String resolvedType, IIntentReceiver resultTo, 16936 int resultCode, String resultData, Bundle resultExtras, 16937 String[] requiredPermissions, int appOp, Bundle options, 16938 boolean serialized, boolean sticky, int userId) { 16939 enforceNotIsolatedCaller("broadcastIntent"); 16940 synchronized(this) { 16941 intent = verifyBroadcastLocked(intent); 16942 16943 final ProcessRecord callerApp = getRecordForAppLocked(caller); 16944 final int callingPid = Binder.getCallingPid(); 16945 final int callingUid = Binder.getCallingUid(); 16946 final long origId = Binder.clearCallingIdentity(); 16947 int res = broadcastIntentLocked(callerApp, 16948 callerApp != null ? callerApp.info.packageName : null, 16949 intent, resolvedType, resultTo, resultCode, resultData, resultExtras, 16950 requiredPermissions, appOp, null, serialized, sticky, 16951 callingPid, callingUid, userId); 16952 Binder.restoreCallingIdentity(origId); 16953 return res; 16954 } 16955 } 16956 16957 16958 int broadcastIntentInPackage(String packageName, int uid, 16959 Intent intent, String resolvedType, IIntentReceiver resultTo, 16960 int resultCode, String resultData, Bundle resultExtras, 16961 String requiredPermission, Bundle options, boolean serialized, boolean sticky, 16962 int userId) { 16963 synchronized(this) { 16964 intent = verifyBroadcastLocked(intent); 16965 16966 final long origId = Binder.clearCallingIdentity(); 16967 String[] requiredPermissions = requiredPermission == null ? null 16968 : new String[] {requiredPermission}; 16969 int res = broadcastIntentLocked(null, packageName, intent, resolvedType, 16970 resultTo, resultCode, resultData, resultExtras, 16971 requiredPermissions, AppOpsManager.OP_NONE, options, serialized, 16972 sticky, -1, uid, userId); 16973 Binder.restoreCallingIdentity(origId); 16974 return res; 16975 } 16976 } 16977 16978 public final void unbroadcastIntent(IApplicationThread caller, Intent intent, int userId) { 16979 // Refuse possible leaked file descriptors 16980 if (intent != null && intent.hasFileDescriptors() == true) { 16981 throw new IllegalArgumentException("File descriptors passed in Intent"); 16982 } 16983 16984 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), 16985 userId, true, ALLOW_NON_FULL, "removeStickyBroadcast", null); 16986 16987 synchronized(this) { 16988 if (checkCallingPermission(android.Manifest.permission.BROADCAST_STICKY) 16989 != PackageManager.PERMISSION_GRANTED) { 16990 String msg = "Permission Denial: unbroadcastIntent() from pid=" 16991 + Binder.getCallingPid() 16992 + ", uid=" + Binder.getCallingUid() 16993 + " requires " + android.Manifest.permission.BROADCAST_STICKY; 16994 Slog.w(TAG, msg); 16995 throw new SecurityException(msg); 16996 } 16997 ArrayMap<String, ArrayList<Intent>> stickies = mStickyBroadcasts.get(userId); 16998 if (stickies != null) { 16999 ArrayList<Intent> list = stickies.get(intent.getAction()); 17000 if (list != null) { 17001 int N = list.size(); 17002 int i; 17003 for (i=0; i<N; i++) { 17004 if (intent.filterEquals(list.get(i))) { 17005 list.remove(i); 17006 break; 17007 } 17008 } 17009 if (list.size() <= 0) { 17010 stickies.remove(intent.getAction()); 17011 } 17012 } 17013 if (stickies.size() <= 0) { 17014 mStickyBroadcasts.remove(userId); 17015 } 17016 } 17017 } 17018 } 17019 17020 void backgroundServicesFinishedLocked(int userId) { 17021 for (BroadcastQueue queue : mBroadcastQueues) { 17022 queue.backgroundServicesFinishedLocked(userId); 17023 } 17024 } 17025 17026 public void finishReceiver(IBinder who, int resultCode, String resultData, 17027 Bundle resultExtras, boolean resultAbort, int flags) { 17028 if (DEBUG_BROADCAST) Slog.v(TAG_BROADCAST, "Finish receiver: " + who); 17029 17030 // Refuse possible leaked file descriptors 17031 if (resultExtras != null && resultExtras.hasFileDescriptors()) { 17032 throw new IllegalArgumentException("File descriptors passed in Bundle"); 17033 } 17034 17035 final long origId = Binder.clearCallingIdentity(); 17036 try { 17037 boolean doNext = false; 17038 BroadcastRecord r; 17039 17040 synchronized(this) { 17041 BroadcastQueue queue = (flags & Intent.FLAG_RECEIVER_FOREGROUND) != 0 17042 ? mFgBroadcastQueue : mBgBroadcastQueue; 17043 r = queue.getMatchingOrderedReceiver(who); 17044 if (r != null) { 17045 doNext = r.queue.finishReceiverLocked(r, resultCode, 17046 resultData, resultExtras, resultAbort, true); 17047 } 17048 } 17049 17050 if (doNext) { 17051 r.queue.processNextBroadcast(false); 17052 } 17053 trimApplications(); 17054 } finally { 17055 Binder.restoreCallingIdentity(origId); 17056 } 17057 } 17058 17059 // ========================================================= 17060 // INSTRUMENTATION 17061 // ========================================================= 17062 17063 public boolean startInstrumentation(ComponentName className, 17064 String profileFile, int flags, Bundle arguments, 17065 IInstrumentationWatcher watcher, IUiAutomationConnection uiAutomationConnection, 17066 int userId, String abiOverride) { 17067 enforceNotIsolatedCaller("startInstrumentation"); 17068 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), 17069 userId, false, ALLOW_FULL_ONLY, "startInstrumentation", null); 17070 // Refuse possible leaked file descriptors 17071 if (arguments != null && arguments.hasFileDescriptors()) { 17072 throw new IllegalArgumentException("File descriptors passed in Bundle"); 17073 } 17074 17075 synchronized(this) { 17076 InstrumentationInfo ii = null; 17077 ApplicationInfo ai = null; 17078 try { 17079 ii = mContext.getPackageManager().getInstrumentationInfo( 17080 className, STOCK_PM_FLAGS); 17081 ai = AppGlobals.getPackageManager().getApplicationInfo( 17082 ii.targetPackage, STOCK_PM_FLAGS, userId); 17083 } catch (PackageManager.NameNotFoundException e) { 17084 } catch (RemoteException e) { 17085 } 17086 if (ii == null) { 17087 reportStartInstrumentationFailure(watcher, className, 17088 "Unable to find instrumentation info for: " + className); 17089 return false; 17090 } 17091 if (ai == null) { 17092 reportStartInstrumentationFailure(watcher, className, 17093 "Unable to find instrumentation target package: " + ii.targetPackage); 17094 return false; 17095 } 17096 17097 int match = mContext.getPackageManager().checkSignatures( 17098 ii.targetPackage, ii.packageName); 17099 if (match < 0 && match != PackageManager.SIGNATURE_FIRST_NOT_SIGNED) { 17100 String msg = "Permission Denial: starting instrumentation " 17101 + className + " from pid=" 17102 + Binder.getCallingPid() 17103 + ", uid=" + Binder.getCallingPid() 17104 + " not allowed because package " + ii.packageName 17105 + " does not have a signature matching the target " 17106 + ii.targetPackage; 17107 reportStartInstrumentationFailure(watcher, className, msg); 17108 throw new SecurityException(msg); 17109 } 17110 17111 final long origId = Binder.clearCallingIdentity(); 17112 // Instrumentation can kill and relaunch even persistent processes 17113 forceStopPackageLocked(ii.targetPackage, -1, true, false, true, true, false, userId, 17114 "start instr"); 17115 ProcessRecord app = addAppLocked(ai, false, abiOverride); 17116 app.instrumentationClass = className; 17117 app.instrumentationInfo = ai; 17118 app.instrumentationProfileFile = profileFile; 17119 app.instrumentationArguments = arguments; 17120 app.instrumentationWatcher = watcher; 17121 app.instrumentationUiAutomationConnection = uiAutomationConnection; 17122 app.instrumentationResultClass = className; 17123 Binder.restoreCallingIdentity(origId); 17124 } 17125 17126 return true; 17127 } 17128 17129 /** 17130 * Report errors that occur while attempting to start Instrumentation. Always writes the 17131 * error to the logs, but if somebody is watching, send the report there too. This enables 17132 * the "am" command to report errors with more information. 17133 * 17134 * @param watcher The IInstrumentationWatcher. Null if there isn't one. 17135 * @param cn The component name of the instrumentation. 17136 * @param report The error report. 17137 */ 17138 private void reportStartInstrumentationFailure(IInstrumentationWatcher watcher, 17139 ComponentName cn, String report) { 17140 Slog.w(TAG, report); 17141 try { 17142 if (watcher != null) { 17143 Bundle results = new Bundle(); 17144 results.putString(Instrumentation.REPORT_KEY_IDENTIFIER, "ActivityManagerService"); 17145 results.putString("Error", report); 17146 watcher.instrumentationStatus(cn, -1, results); 17147 } 17148 } catch (RemoteException e) { 17149 Slog.w(TAG, e); 17150 } 17151 } 17152 17153 void finishInstrumentationLocked(ProcessRecord app, int resultCode, Bundle results) { 17154 if (app.instrumentationWatcher != null) { 17155 try { 17156 // NOTE: IInstrumentationWatcher *must* be oneway here 17157 app.instrumentationWatcher.instrumentationFinished( 17158 app.instrumentationClass, 17159 resultCode, 17160 results); 17161 } catch (RemoteException e) { 17162 } 17163 } 17164 17165 // Can't call out of the system process with a lock held, so post a message. 17166 if (app.instrumentationUiAutomationConnection != null) { 17167 mHandler.obtainMessage(SHUTDOWN_UI_AUTOMATION_CONNECTION_MSG, 17168 app.instrumentationUiAutomationConnection).sendToTarget(); 17169 } 17170 17171 app.instrumentationWatcher = null; 17172 app.instrumentationUiAutomationConnection = null; 17173 app.instrumentationClass = null; 17174 app.instrumentationInfo = null; 17175 app.instrumentationProfileFile = null; 17176 app.instrumentationArguments = null; 17177 17178 forceStopPackageLocked(app.info.packageName, -1, false, false, true, true, false, app.userId, 17179 "finished inst"); 17180 } 17181 17182 public void finishInstrumentation(IApplicationThread target, 17183 int resultCode, Bundle results) { 17184 int userId = UserHandle.getCallingUserId(); 17185 // Refuse possible leaked file descriptors 17186 if (results != null && results.hasFileDescriptors()) { 17187 throw new IllegalArgumentException("File descriptors passed in Intent"); 17188 } 17189 17190 synchronized(this) { 17191 ProcessRecord app = getRecordForAppLocked(target); 17192 if (app == null) { 17193 Slog.w(TAG, "finishInstrumentation: no app for " + target); 17194 return; 17195 } 17196 final long origId = Binder.clearCallingIdentity(); 17197 finishInstrumentationLocked(app, resultCode, results); 17198 Binder.restoreCallingIdentity(origId); 17199 } 17200 } 17201 17202 // ========================================================= 17203 // CONFIGURATION 17204 // ========================================================= 17205 17206 public ConfigurationInfo getDeviceConfigurationInfo() { 17207 ConfigurationInfo config = new ConfigurationInfo(); 17208 synchronized (this) { 17209 config.reqTouchScreen = mConfiguration.touchscreen; 17210 config.reqKeyboardType = mConfiguration.keyboard; 17211 config.reqNavigation = mConfiguration.navigation; 17212 if (mConfiguration.navigation == Configuration.NAVIGATION_DPAD 17213 || mConfiguration.navigation == Configuration.NAVIGATION_TRACKBALL) { 17214 config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_FIVE_WAY_NAV; 17215 } 17216 if (mConfiguration.keyboard != Configuration.KEYBOARD_UNDEFINED 17217 && mConfiguration.keyboard != Configuration.KEYBOARD_NOKEYS) { 17218 config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_HARD_KEYBOARD; 17219 } 17220 config.reqGlEsVersion = GL_ES_VERSION; 17221 } 17222 return config; 17223 } 17224 17225 ActivityStack getFocusedStack() { 17226 return mStackSupervisor.getFocusedStack(); 17227 } 17228 17229 @Override 17230 public int getFocusedStackId() throws RemoteException { 17231 ActivityStack focusedStack = getFocusedStack(); 17232 if (focusedStack != null) { 17233 return focusedStack.getStackId(); 17234 } 17235 return -1; 17236 } 17237 17238 public Configuration getConfiguration() { 17239 Configuration ci; 17240 synchronized(this) { 17241 ci = new Configuration(mConfiguration); 17242 ci.userSetLocale = false; 17243 } 17244 return ci; 17245 } 17246 17247 public void updatePersistentConfiguration(Configuration values) { 17248 enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, 17249 "updateConfiguration()"); 17250 enforceWriteSettingsPermission("updateConfiguration()"); 17251 if (values == null) { 17252 throw new NullPointerException("Configuration must not be null"); 17253 } 17254 17255 synchronized(this) { 17256 final long origId = Binder.clearCallingIdentity(); 17257 updateConfigurationLocked(values, null, true, false); 17258 Binder.restoreCallingIdentity(origId); 17259 } 17260 } 17261 17262 private void enforceWriteSettingsPermission(String func) { 17263 int uid = Binder.getCallingUid(); 17264 if (uid == Process.ROOT_UID) { 17265 return; 17266 } 17267 17268 if (Settings.checkAndNoteWriteSettingsOperation(mContext, uid, 17269 Settings.getPackageNameForUid(mContext, uid), false)) { 17270 return; 17271 } 17272 17273 String msg = "Permission Denial: " + func + " from pid=" 17274 + Binder.getCallingPid() 17275 + ", uid=" + uid 17276 + " requires " + android.Manifest.permission.WRITE_SETTINGS; 17277 Slog.w(TAG, msg); 17278 throw new SecurityException(msg); 17279 } 17280 17281 public void updateConfiguration(Configuration values) { 17282 enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, 17283 "updateConfiguration()"); 17284 17285 synchronized(this) { 17286 if (values == null && mWindowManager != null) { 17287 // sentinel: fetch the current configuration from the window manager 17288 values = mWindowManager.computeNewConfiguration(); 17289 } 17290 17291 if (mWindowManager != null) { 17292 mProcessList.applyDisplaySize(mWindowManager); 17293 } 17294 17295 final long origId = Binder.clearCallingIdentity(); 17296 if (values != null) { 17297 Settings.System.clearConfiguration(values); 17298 } 17299 updateConfigurationLocked(values, null, false, false); 17300 Binder.restoreCallingIdentity(origId); 17301 } 17302 } 17303 17304 /** 17305 * Do either or both things: (1) change the current configuration, and (2) 17306 * make sure the given activity is running with the (now) current 17307 * configuration. Returns true if the activity has been left running, or 17308 * false if <var>starting</var> is being destroyed to match the new 17309 * configuration. 17310 * @param persistent TODO 17311 */ 17312 boolean updateConfigurationLocked(Configuration values, 17313 ActivityRecord starting, boolean persistent, boolean initLocale) { 17314 int changes = 0; 17315 17316 if (values != null) { 17317 Configuration newConfig = new Configuration(mConfiguration); 17318 changes = newConfig.updateFrom(values); 17319 if (changes != 0) { 17320 if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.i(TAG_CONFIGURATION, 17321 "Updating configuration to: " + values); 17322 17323 EventLog.writeEvent(EventLogTags.CONFIGURATION_CHANGED, changes); 17324 17325 if (!initLocale && values.locale != null && values.userSetLocale) { 17326 final String languageTag = values.locale.toLanguageTag(); 17327 SystemProperties.set("persist.sys.locale", languageTag); 17328 mHandler.sendMessage(mHandler.obtainMessage(SEND_LOCALE_TO_MOUNT_DAEMON_MSG, 17329 values.locale)); 17330 } 17331 17332 mConfigurationSeq++; 17333 if (mConfigurationSeq <= 0) { 17334 mConfigurationSeq = 1; 17335 } 17336 newConfig.seq = mConfigurationSeq; 17337 mConfiguration = newConfig; 17338 Slog.i(TAG, "Config changes=" + Integer.toHexString(changes) + " " + newConfig); 17339 mUsageStatsService.reportConfigurationChange(newConfig, mCurrentUserId); 17340 //mUsageStatsService.noteStartConfig(newConfig); 17341 17342 final Configuration configCopy = new Configuration(mConfiguration); 17343 17344 // TODO: If our config changes, should we auto dismiss any currently 17345 // showing dialogs? 17346 mShowDialogs = shouldShowDialogs(newConfig); 17347 17348 AttributeCache ac = AttributeCache.instance(); 17349 if (ac != null) { 17350 ac.updateConfiguration(configCopy); 17351 } 17352 17353 // Make sure all resources in our process are updated 17354 // right now, so that anyone who is going to retrieve 17355 // resource values after we return will be sure to get 17356 // the new ones. This is especially important during 17357 // boot, where the first config change needs to guarantee 17358 // all resources have that config before following boot 17359 // code is executed. 17360 mSystemThread.applyConfigurationToResources(configCopy); 17361 17362 if (persistent && Settings.System.hasInterestingConfigurationChanges(changes)) { 17363 Message msg = mHandler.obtainMessage(UPDATE_CONFIGURATION_MSG); 17364 msg.obj = new Configuration(configCopy); 17365 mHandler.sendMessage(msg); 17366 } 17367 17368 for (int i=mLruProcesses.size()-1; i>=0; i--) { 17369 ProcessRecord app = mLruProcesses.get(i); 17370 try { 17371 if (app.thread != null) { 17372 if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Sending to proc " 17373 + app.processName + " new config " + mConfiguration); 17374 app.thread.scheduleConfigurationChanged(configCopy); 17375 } 17376 } catch (Exception e) { 17377 } 17378 } 17379 Intent intent = new Intent(Intent.ACTION_CONFIGURATION_CHANGED); 17380 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 17381 | Intent.FLAG_RECEIVER_REPLACE_PENDING 17382 | Intent.FLAG_RECEIVER_FOREGROUND); 17383 broadcastIntentLocked(null, null, intent, null, null, 0, null, null, 17384 null, AppOpsManager.OP_NONE, null, false, false, 17385 MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 17386 if ((changes&ActivityInfo.CONFIG_LOCALE) != 0) { 17387 intent = new Intent(Intent.ACTION_LOCALE_CHANGED); 17388 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); 17389 if (!mProcessesReady) { 17390 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 17391 } 17392 broadcastIntentLocked(null, null, intent, 17393 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 17394 null, false, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 17395 } 17396 } 17397 } 17398 17399 boolean kept = true; 17400 final ActivityStack mainStack = mStackSupervisor.getFocusedStack(); 17401 // mainStack is null during startup. 17402 if (mainStack != null) { 17403 if (changes != 0 && starting == null) { 17404 // If the configuration changed, and the caller is not already 17405 // in the process of starting an activity, then find the top 17406 // activity to check if its configuration needs to change. 17407 starting = mainStack.topRunningActivityLocked(null); 17408 } 17409 17410 if (starting != null) { 17411 kept = mainStack.ensureActivityConfigurationLocked(starting, changes); 17412 // And we need to make sure at this point that all other activities 17413 // are made visible with the correct configuration. 17414 mStackSupervisor.ensureActivitiesVisibleLocked(starting, changes); 17415 } 17416 } 17417 17418 if (values != null && mWindowManager != null) { 17419 mWindowManager.setNewConfiguration(mConfiguration); 17420 } 17421 17422 return kept; 17423 } 17424 17425 /** 17426 * Decide based on the configuration whether we should shouw the ANR, 17427 * crash, etc dialogs. The idea is that if there is no affordnace to 17428 * press the on-screen buttons, we shouldn't show the dialog. 17429 * 17430 * A thought: SystemUI might also want to get told about this, the Power 17431 * dialog / global actions also might want different behaviors. 17432 */ 17433 private static final boolean shouldShowDialogs(Configuration config) { 17434 return !(config.keyboard == Configuration.KEYBOARD_NOKEYS 17435 && config.touchscreen == Configuration.TOUCHSCREEN_NOTOUCH 17436 && config.navigation == Configuration.NAVIGATION_NONAV); 17437 } 17438 17439 @Override 17440 public boolean shouldUpRecreateTask(IBinder token, String destAffinity) { 17441 synchronized (this) { 17442 ActivityRecord srec = ActivityRecord.forTokenLocked(token); 17443 if (srec != null) { 17444 return srec.task.stack.shouldUpRecreateTaskLocked(srec, destAffinity); 17445 } 17446 } 17447 return false; 17448 } 17449 17450 public boolean navigateUpTo(IBinder token, Intent destIntent, int resultCode, 17451 Intent resultData) { 17452 17453 synchronized (this) { 17454 final ActivityRecord r = ActivityRecord.forTokenLocked(token); 17455 if (r != null) { 17456 return r.task.stack.navigateUpToLocked(r, destIntent, resultCode, resultData); 17457 } 17458 return false; 17459 } 17460 } 17461 17462 public int getLaunchedFromUid(IBinder activityToken) { 17463 ActivityRecord srec; 17464 synchronized (this) { 17465 srec = ActivityRecord.forTokenLocked(activityToken); 17466 } 17467 if (srec == null) { 17468 return -1; 17469 } 17470 return srec.launchedFromUid; 17471 } 17472 17473 public String getLaunchedFromPackage(IBinder activityToken) { 17474 ActivityRecord srec; 17475 synchronized (this) { 17476 srec = ActivityRecord.forTokenLocked(activityToken); 17477 } 17478 if (srec == null) { 17479 return null; 17480 } 17481 return srec.launchedFromPackage; 17482 } 17483 17484 // ========================================================= 17485 // LIFETIME MANAGEMENT 17486 // ========================================================= 17487 17488 // Returns which broadcast queue the app is the current [or imminent] receiver 17489 // on, or 'null' if the app is not an active broadcast recipient. 17490 private BroadcastQueue isReceivingBroadcast(ProcessRecord app) { 17491 BroadcastRecord r = app.curReceiver; 17492 if (r != null) { 17493 return r.queue; 17494 } 17495 17496 // It's not the current receiver, but it might be starting up to become one 17497 synchronized (this) { 17498 for (BroadcastQueue queue : mBroadcastQueues) { 17499 r = queue.mPendingBroadcast; 17500 if (r != null && r.curApp == app) { 17501 // found it; report which queue it's in 17502 return queue; 17503 } 17504 } 17505 } 17506 17507 return null; 17508 } 17509 17510 Association startAssociationLocked(int sourceUid, String sourceProcess, int targetUid, 17511 ComponentName targetComponent, String targetProcess) { 17512 if (!mTrackingAssociations) { 17513 return null; 17514 } 17515 ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>> components 17516 = mAssociations.get(targetUid); 17517 if (components == null) { 17518 components = new ArrayMap<>(); 17519 mAssociations.put(targetUid, components); 17520 } 17521 SparseArray<ArrayMap<String, Association>> sourceUids = components.get(targetComponent); 17522 if (sourceUids == null) { 17523 sourceUids = new SparseArray<>(); 17524 components.put(targetComponent, sourceUids); 17525 } 17526 ArrayMap<String, Association> sourceProcesses = sourceUids.get(sourceUid); 17527 if (sourceProcesses == null) { 17528 sourceProcesses = new ArrayMap<>(); 17529 sourceUids.put(sourceUid, sourceProcesses); 17530 } 17531 Association ass = sourceProcesses.get(sourceProcess); 17532 if (ass == null) { 17533 ass = new Association(sourceUid, sourceProcess, targetUid, targetComponent, 17534 targetProcess); 17535 sourceProcesses.put(sourceProcess, ass); 17536 } 17537 ass.mCount++; 17538 ass.mNesting++; 17539 if (ass.mNesting == 1) { 17540 ass.mStartTime = SystemClock.uptimeMillis(); 17541 } 17542 return ass; 17543 } 17544 17545 void stopAssociationLocked(int sourceUid, String sourceProcess, int targetUid, 17546 ComponentName targetComponent) { 17547 if (!mTrackingAssociations) { 17548 return; 17549 } 17550 ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>> components 17551 = mAssociations.get(targetUid); 17552 if (components == null) { 17553 return; 17554 } 17555 SparseArray<ArrayMap<String, Association>> sourceUids = components.get(targetComponent); 17556 if (sourceUids == null) { 17557 return; 17558 } 17559 ArrayMap<String, Association> sourceProcesses = sourceUids.get(sourceUid); 17560 if (sourceProcesses == null) { 17561 return; 17562 } 17563 Association ass = sourceProcesses.get(sourceProcess); 17564 if (ass == null || ass.mNesting <= 0) { 17565 return; 17566 } 17567 ass.mNesting--; 17568 if (ass.mNesting == 0) { 17569 ass.mTime += SystemClock.uptimeMillis() - ass.mStartTime; 17570 } 17571 } 17572 17573 private final int computeOomAdjLocked(ProcessRecord app, int cachedAdj, ProcessRecord TOP_APP, 17574 boolean doingAll, long now) { 17575 if (mAdjSeq == app.adjSeq) { 17576 // This adjustment has already been computed. 17577 return app.curRawAdj; 17578 } 17579 17580 if (app.thread == null) { 17581 app.adjSeq = mAdjSeq; 17582 app.curSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 17583 app.curProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 17584 return (app.curAdj=app.curRawAdj=ProcessList.CACHED_APP_MAX_ADJ); 17585 } 17586 17587 app.adjTypeCode = ActivityManager.RunningAppProcessInfo.REASON_UNKNOWN; 17588 app.adjSource = null; 17589 app.adjTarget = null; 17590 app.empty = false; 17591 app.cached = false; 17592 17593 final int activitiesSize = app.activities.size(); 17594 17595 if (app.maxAdj <= ProcessList.FOREGROUND_APP_ADJ) { 17596 // The max adjustment doesn't allow this app to be anything 17597 // below foreground, so it is not worth doing work for it. 17598 app.adjType = "fixed"; 17599 app.adjSeq = mAdjSeq; 17600 app.curRawAdj = app.maxAdj; 17601 app.foregroundActivities = false; 17602 app.curSchedGroup = Process.THREAD_GROUP_DEFAULT; 17603 app.curProcState = ActivityManager.PROCESS_STATE_PERSISTENT; 17604 // System processes can do UI, and when they do we want to have 17605 // them trim their memory after the user leaves the UI. To 17606 // facilitate this, here we need to determine whether or not it 17607 // is currently showing UI. 17608 app.systemNoUi = true; 17609 if (app == TOP_APP) { 17610 app.systemNoUi = false; 17611 } else if (activitiesSize > 0) { 17612 for (int j = 0; j < activitiesSize; j++) { 17613 final ActivityRecord r = app.activities.get(j); 17614 if (r.visible) { 17615 app.systemNoUi = false; 17616 } 17617 } 17618 } 17619 if (!app.systemNoUi) { 17620 app.curProcState = ActivityManager.PROCESS_STATE_PERSISTENT_UI; 17621 } 17622 return (app.curAdj=app.maxAdj); 17623 } 17624 17625 app.systemNoUi = false; 17626 17627 final int PROCESS_STATE_TOP = mTopProcessState; 17628 17629 // Determine the importance of the process, starting with most 17630 // important to least, and assign an appropriate OOM adjustment. 17631 int adj; 17632 int schedGroup; 17633 int procState; 17634 boolean foregroundActivities = false; 17635 BroadcastQueue queue; 17636 if (app == TOP_APP) { 17637 // The last app on the list is the foreground app. 17638 adj = ProcessList.FOREGROUND_APP_ADJ; 17639 schedGroup = Process.THREAD_GROUP_DEFAULT; 17640 app.adjType = "top-activity"; 17641 foregroundActivities = true; 17642 procState = PROCESS_STATE_TOP; 17643 } else if (app.instrumentationClass != null) { 17644 // Don't want to kill running instrumentation. 17645 adj = ProcessList.FOREGROUND_APP_ADJ; 17646 schedGroup = Process.THREAD_GROUP_DEFAULT; 17647 app.adjType = "instrumentation"; 17648 procState = ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE; 17649 } else if ((queue = isReceivingBroadcast(app)) != null) { 17650 // An app that is currently receiving a broadcast also 17651 // counts as being in the foreground for OOM killer purposes. 17652 // It's placed in a sched group based on the nature of the 17653 // broadcast as reflected by which queue it's active in. 17654 adj = ProcessList.FOREGROUND_APP_ADJ; 17655 schedGroup = (queue == mFgBroadcastQueue) 17656 ? Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE; 17657 app.adjType = "broadcast"; 17658 procState = ActivityManager.PROCESS_STATE_RECEIVER; 17659 } else if (app.executingServices.size() > 0) { 17660 // An app that is currently executing a service callback also 17661 // counts as being in the foreground. 17662 adj = ProcessList.FOREGROUND_APP_ADJ; 17663 schedGroup = app.execServicesFg ? 17664 Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE; 17665 app.adjType = "exec-service"; 17666 procState = ActivityManager.PROCESS_STATE_SERVICE; 17667 //Slog.i(TAG, "EXEC " + (app.execServicesFg ? "FG" : "BG") + ": " + app); 17668 } else { 17669 // As far as we know the process is empty. We may change our mind later. 17670 schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 17671 // At this point we don't actually know the adjustment. Use the cached adj 17672 // value that the caller wants us to. 17673 adj = cachedAdj; 17674 procState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 17675 app.cached = true; 17676 app.empty = true; 17677 app.adjType = "cch-empty"; 17678 } 17679 17680 // Examine all activities if not already foreground. 17681 if (!foregroundActivities && activitiesSize > 0) { 17682 for (int j = 0; j < activitiesSize; j++) { 17683 final ActivityRecord r = app.activities.get(j); 17684 if (r.app != app) { 17685 Slog.w(TAG, "Wtf, activity " + r + " in proc activity list not using proc " 17686 + app + "?!? Using " + r.app + " instead."); 17687 continue; 17688 } 17689 if (r.visible) { 17690 // App has a visible activity; only upgrade adjustment. 17691 if (adj > ProcessList.VISIBLE_APP_ADJ) { 17692 adj = ProcessList.VISIBLE_APP_ADJ; 17693 app.adjType = "visible"; 17694 } 17695 if (procState > PROCESS_STATE_TOP) { 17696 procState = PROCESS_STATE_TOP; 17697 } 17698 schedGroup = Process.THREAD_GROUP_DEFAULT; 17699 app.cached = false; 17700 app.empty = false; 17701 foregroundActivities = true; 17702 break; 17703 } else if (r.state == ActivityState.PAUSING || r.state == ActivityState.PAUSED) { 17704 if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) { 17705 adj = ProcessList.PERCEPTIBLE_APP_ADJ; 17706 app.adjType = "pausing"; 17707 } 17708 if (procState > PROCESS_STATE_TOP) { 17709 procState = PROCESS_STATE_TOP; 17710 } 17711 schedGroup = Process.THREAD_GROUP_DEFAULT; 17712 app.cached = false; 17713 app.empty = false; 17714 foregroundActivities = true; 17715 } else if (r.state == ActivityState.STOPPING) { 17716 if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) { 17717 adj = ProcessList.PERCEPTIBLE_APP_ADJ; 17718 app.adjType = "stopping"; 17719 } 17720 // For the process state, we will at this point consider the 17721 // process to be cached. It will be cached either as an activity 17722 // or empty depending on whether the activity is finishing. We do 17723 // this so that we can treat the process as cached for purposes of 17724 // memory trimming (determing current memory level, trim command to 17725 // send to process) since there can be an arbitrary number of stopping 17726 // processes and they should soon all go into the cached state. 17727 if (!r.finishing) { 17728 if (procState > ActivityManager.PROCESS_STATE_LAST_ACTIVITY) { 17729 procState = ActivityManager.PROCESS_STATE_LAST_ACTIVITY; 17730 } 17731 } 17732 app.cached = false; 17733 app.empty = false; 17734 foregroundActivities = true; 17735 } else { 17736 if (procState > ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 17737 procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY; 17738 app.adjType = "cch-act"; 17739 } 17740 } 17741 } 17742 } 17743 17744 if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) { 17745 if (app.foregroundServices) { 17746 // The user is aware of this app, so make it visible. 17747 adj = ProcessList.PERCEPTIBLE_APP_ADJ; 17748 procState = ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE; 17749 app.cached = false; 17750 app.adjType = "fg-service"; 17751 schedGroup = Process.THREAD_GROUP_DEFAULT; 17752 } else if (app.forcingToForeground != null) { 17753 // The user is aware of this app, so make it visible. 17754 adj = ProcessList.PERCEPTIBLE_APP_ADJ; 17755 procState = ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 17756 app.cached = false; 17757 app.adjType = "force-fg"; 17758 app.adjSource = app.forcingToForeground; 17759 schedGroup = Process.THREAD_GROUP_DEFAULT; 17760 } 17761 } 17762 17763 if (app == mHeavyWeightProcess) { 17764 if (adj > ProcessList.HEAVY_WEIGHT_APP_ADJ) { 17765 // We don't want to kill the current heavy-weight process. 17766 adj = ProcessList.HEAVY_WEIGHT_APP_ADJ; 17767 schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 17768 app.cached = false; 17769 app.adjType = "heavy"; 17770 } 17771 if (procState > ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) { 17772 procState = ActivityManager.PROCESS_STATE_HEAVY_WEIGHT; 17773 } 17774 } 17775 17776 if (app == mHomeProcess) { 17777 if (adj > ProcessList.HOME_APP_ADJ) { 17778 // This process is hosting what we currently consider to be the 17779 // home app, so we don't want to let it go into the background. 17780 adj = ProcessList.HOME_APP_ADJ; 17781 schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 17782 app.cached = false; 17783 app.adjType = "home"; 17784 } 17785 if (procState > ActivityManager.PROCESS_STATE_HOME) { 17786 procState = ActivityManager.PROCESS_STATE_HOME; 17787 } 17788 } 17789 17790 if (app == mPreviousProcess && app.activities.size() > 0) { 17791 if (adj > ProcessList.PREVIOUS_APP_ADJ) { 17792 // This was the previous process that showed UI to the user. 17793 // We want to try to keep it around more aggressively, to give 17794 // a good experience around switching between two apps. 17795 adj = ProcessList.PREVIOUS_APP_ADJ; 17796 schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 17797 app.cached = false; 17798 app.adjType = "previous"; 17799 } 17800 if (procState > ActivityManager.PROCESS_STATE_LAST_ACTIVITY) { 17801 procState = ActivityManager.PROCESS_STATE_LAST_ACTIVITY; 17802 } 17803 } 17804 17805 if (false) Slog.i(TAG, "OOM " + app + ": initial adj=" + adj 17806 + " reason=" + app.adjType); 17807 17808 // By default, we use the computed adjustment. It may be changed if 17809 // there are applications dependent on our services or providers, but 17810 // this gives us a baseline and makes sure we don't get into an 17811 // infinite recursion. 17812 app.adjSeq = mAdjSeq; 17813 app.curRawAdj = adj; 17814 app.hasStartedServices = false; 17815 17816 if (mBackupTarget != null && app == mBackupTarget.app) { 17817 // If possible we want to avoid killing apps while they're being backed up 17818 if (adj > ProcessList.BACKUP_APP_ADJ) { 17819 if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "oom BACKUP_APP_ADJ for " + app); 17820 adj = ProcessList.BACKUP_APP_ADJ; 17821 if (procState > ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND) { 17822 procState = ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND; 17823 } 17824 app.adjType = "backup"; 17825 app.cached = false; 17826 } 17827 if (procState > ActivityManager.PROCESS_STATE_BACKUP) { 17828 procState = ActivityManager.PROCESS_STATE_BACKUP; 17829 } 17830 } 17831 17832 boolean mayBeTop = false; 17833 17834 for (int is = app.services.size()-1; 17835 is >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ 17836 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 17837 || procState > ActivityManager.PROCESS_STATE_TOP); 17838 is--) { 17839 ServiceRecord s = app.services.valueAt(is); 17840 if (s.startRequested) { 17841 app.hasStartedServices = true; 17842 if (procState > ActivityManager.PROCESS_STATE_SERVICE) { 17843 procState = ActivityManager.PROCESS_STATE_SERVICE; 17844 } 17845 if (app.hasShownUi && app != mHomeProcess) { 17846 // If this process has shown some UI, let it immediately 17847 // go to the LRU list because it may be pretty heavy with 17848 // UI stuff. We'll tag it with a label just to help 17849 // debug and understand what is going on. 17850 if (adj > ProcessList.SERVICE_ADJ) { 17851 app.adjType = "cch-started-ui-services"; 17852 } 17853 } else { 17854 if (now < (s.lastActivity + ActiveServices.MAX_SERVICE_INACTIVITY)) { 17855 // This service has seen some activity within 17856 // recent memory, so we will keep its process ahead 17857 // of the background processes. 17858 if (adj > ProcessList.SERVICE_ADJ) { 17859 adj = ProcessList.SERVICE_ADJ; 17860 app.adjType = "started-services"; 17861 app.cached = false; 17862 } 17863 } 17864 // If we have let the service slide into the background 17865 // state, still have some text describing what it is doing 17866 // even though the service no longer has an impact. 17867 if (adj > ProcessList.SERVICE_ADJ) { 17868 app.adjType = "cch-started-services"; 17869 } 17870 } 17871 } 17872 for (int conni = s.connections.size()-1; 17873 conni >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ 17874 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 17875 || procState > ActivityManager.PROCESS_STATE_TOP); 17876 conni--) { 17877 ArrayList<ConnectionRecord> clist = s.connections.valueAt(conni); 17878 for (int i = 0; 17879 i < clist.size() && (adj > ProcessList.FOREGROUND_APP_ADJ 17880 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 17881 || procState > ActivityManager.PROCESS_STATE_TOP); 17882 i++) { 17883 // XXX should compute this based on the max of 17884 // all connected clients. 17885 ConnectionRecord cr = clist.get(i); 17886 if (cr.binding.client == app) { 17887 // Binding to ourself is not interesting. 17888 continue; 17889 } 17890 if ((cr.flags&Context.BIND_WAIVE_PRIORITY) == 0) { 17891 ProcessRecord client = cr.binding.client; 17892 int clientAdj = computeOomAdjLocked(client, cachedAdj, 17893 TOP_APP, doingAll, now); 17894 int clientProcState = client.curProcState; 17895 if (clientProcState >= ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 17896 // If the other app is cached for any reason, for purposes here 17897 // we are going to consider it empty. The specific cached state 17898 // doesn't propagate except under certain conditions. 17899 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 17900 } 17901 String adjType = null; 17902 if ((cr.flags&Context.BIND_ALLOW_OOM_MANAGEMENT) != 0) { 17903 // Not doing bind OOM management, so treat 17904 // this guy more like a started service. 17905 if (app.hasShownUi && app != mHomeProcess) { 17906 // If this process has shown some UI, let it immediately 17907 // go to the LRU list because it may be pretty heavy with 17908 // UI stuff. We'll tag it with a label just to help 17909 // debug and understand what is going on. 17910 if (adj > clientAdj) { 17911 adjType = "cch-bound-ui-services"; 17912 } 17913 app.cached = false; 17914 clientAdj = adj; 17915 clientProcState = procState; 17916 } else { 17917 if (now >= (s.lastActivity 17918 + ActiveServices.MAX_SERVICE_INACTIVITY)) { 17919 // This service has not seen activity within 17920 // recent memory, so allow it to drop to the 17921 // LRU list if there is no other reason to keep 17922 // it around. We'll also tag it with a label just 17923 // to help debug and undertand what is going on. 17924 if (adj > clientAdj) { 17925 adjType = "cch-bound-services"; 17926 } 17927 clientAdj = adj; 17928 } 17929 } 17930 } 17931 if (adj > clientAdj) { 17932 // If this process has recently shown UI, and 17933 // the process that is binding to it is less 17934 // important than being visible, then we don't 17935 // care about the binding as much as we care 17936 // about letting this process get into the LRU 17937 // list to be killed and restarted if needed for 17938 // memory. 17939 if (app.hasShownUi && app != mHomeProcess 17940 && clientAdj > ProcessList.PERCEPTIBLE_APP_ADJ) { 17941 adjType = "cch-bound-ui-services"; 17942 } else { 17943 if ((cr.flags&(Context.BIND_ABOVE_CLIENT 17944 |Context.BIND_IMPORTANT)) != 0) { 17945 adj = clientAdj >= ProcessList.PERSISTENT_SERVICE_ADJ 17946 ? clientAdj : ProcessList.PERSISTENT_SERVICE_ADJ; 17947 } else if ((cr.flags&Context.BIND_NOT_VISIBLE) != 0 17948 && clientAdj < ProcessList.PERCEPTIBLE_APP_ADJ 17949 && adj > ProcessList.PERCEPTIBLE_APP_ADJ) { 17950 adj = ProcessList.PERCEPTIBLE_APP_ADJ; 17951 } else if (clientAdj > ProcessList.VISIBLE_APP_ADJ) { 17952 adj = clientAdj; 17953 } else { 17954 if (adj > ProcessList.VISIBLE_APP_ADJ) { 17955 adj = ProcessList.VISIBLE_APP_ADJ; 17956 } 17957 } 17958 if (!client.cached) { 17959 app.cached = false; 17960 } 17961 adjType = "service"; 17962 } 17963 } 17964 if ((cr.flags&Context.BIND_NOT_FOREGROUND) == 0) { 17965 if (client.curSchedGroup == Process.THREAD_GROUP_DEFAULT) { 17966 schedGroup = Process.THREAD_GROUP_DEFAULT; 17967 } 17968 if (clientProcState <= ActivityManager.PROCESS_STATE_TOP) { 17969 if (clientProcState == ActivityManager.PROCESS_STATE_TOP) { 17970 // Special handling of clients who are in the top state. 17971 // We *may* want to consider this process to be in the 17972 // top state as well, but only if there is not another 17973 // reason for it to be running. Being on the top is a 17974 // special state, meaning you are specifically running 17975 // for the current top app. If the process is already 17976 // running in the background for some other reason, it 17977 // is more important to continue considering it to be 17978 // in the background state. 17979 mayBeTop = true; 17980 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 17981 } else { 17982 // Special handling for above-top states (persistent 17983 // processes). These should not bring the current process 17984 // into the top state, since they are not on top. Instead 17985 // give them the best state after that. 17986 if ((cr.flags&Context.BIND_FOREGROUND_SERVICE) != 0) { 17987 clientProcState = 17988 ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE; 17989 } else if (mWakefulness 17990 == PowerManagerInternal.WAKEFULNESS_AWAKE && 17991 (cr.flags&Context.BIND_FOREGROUND_SERVICE_WHILE_AWAKE) 17992 != 0) { 17993 clientProcState = 17994 ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE; 17995 } else { 17996 clientProcState = 17997 ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 17998 } 17999 } 18000 } 18001 } else { 18002 if (clientProcState < 18003 ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND) { 18004 clientProcState = 18005 ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND; 18006 } 18007 } 18008 if (procState > clientProcState) { 18009 procState = clientProcState; 18010 } 18011 if (procState < ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND 18012 && (cr.flags&Context.BIND_SHOWING_UI) != 0) { 18013 app.pendingUiClean = true; 18014 } 18015 if (adjType != null) { 18016 app.adjType = adjType; 18017 app.adjTypeCode = ActivityManager.RunningAppProcessInfo 18018 .REASON_SERVICE_IN_USE; 18019 app.adjSource = cr.binding.client; 18020 app.adjSourceProcState = clientProcState; 18021 app.adjTarget = s.name; 18022 } 18023 } 18024 if ((cr.flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) { 18025 app.treatLikeActivity = true; 18026 } 18027 final ActivityRecord a = cr.activity; 18028 if ((cr.flags&Context.BIND_ADJUST_WITH_ACTIVITY) != 0) { 18029 if (a != null && adj > ProcessList.FOREGROUND_APP_ADJ && 18030 (a.visible || a.state == ActivityState.RESUMED 18031 || a.state == ActivityState.PAUSING)) { 18032 adj = ProcessList.FOREGROUND_APP_ADJ; 18033 if ((cr.flags&Context.BIND_NOT_FOREGROUND) == 0) { 18034 schedGroup = Process.THREAD_GROUP_DEFAULT; 18035 } 18036 app.cached = false; 18037 app.adjType = "service"; 18038 app.adjTypeCode = ActivityManager.RunningAppProcessInfo 18039 .REASON_SERVICE_IN_USE; 18040 app.adjSource = a; 18041 app.adjSourceProcState = procState; 18042 app.adjTarget = s.name; 18043 } 18044 } 18045 } 18046 } 18047 } 18048 18049 for (int provi = app.pubProviders.size()-1; 18050 provi >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ 18051 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 18052 || procState > ActivityManager.PROCESS_STATE_TOP); 18053 provi--) { 18054 ContentProviderRecord cpr = app.pubProviders.valueAt(provi); 18055 for (int i = cpr.connections.size()-1; 18056 i >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ 18057 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 18058 || procState > ActivityManager.PROCESS_STATE_TOP); 18059 i--) { 18060 ContentProviderConnection conn = cpr.connections.get(i); 18061 ProcessRecord client = conn.client; 18062 if (client == app) { 18063 // Being our own client is not interesting. 18064 continue; 18065 } 18066 int clientAdj = computeOomAdjLocked(client, cachedAdj, TOP_APP, doingAll, now); 18067 int clientProcState = client.curProcState; 18068 if (clientProcState >= ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 18069 // If the other app is cached for any reason, for purposes here 18070 // we are going to consider it empty. 18071 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18072 } 18073 if (adj > clientAdj) { 18074 if (app.hasShownUi && app != mHomeProcess 18075 && clientAdj > ProcessList.PERCEPTIBLE_APP_ADJ) { 18076 app.adjType = "cch-ui-provider"; 18077 } else { 18078 adj = clientAdj > ProcessList.FOREGROUND_APP_ADJ 18079 ? clientAdj : ProcessList.FOREGROUND_APP_ADJ; 18080 app.adjType = "provider"; 18081 } 18082 app.cached &= client.cached; 18083 app.adjTypeCode = ActivityManager.RunningAppProcessInfo 18084 .REASON_PROVIDER_IN_USE; 18085 app.adjSource = client; 18086 app.adjSourceProcState = clientProcState; 18087 app.adjTarget = cpr.name; 18088 } 18089 if (clientProcState <= ActivityManager.PROCESS_STATE_TOP) { 18090 if (clientProcState == ActivityManager.PROCESS_STATE_TOP) { 18091 // Special handling of clients who are in the top state. 18092 // We *may* want to consider this process to be in the 18093 // top state as well, but only if there is not another 18094 // reason for it to be running. Being on the top is a 18095 // special state, meaning you are specifically running 18096 // for the current top app. If the process is already 18097 // running in the background for some other reason, it 18098 // is more important to continue considering it to be 18099 // in the background state. 18100 mayBeTop = true; 18101 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18102 } else { 18103 // Special handling for above-top states (persistent 18104 // processes). These should not bring the current process 18105 // into the top state, since they are not on top. Instead 18106 // give them the best state after that. 18107 clientProcState = 18108 ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE; 18109 } 18110 } 18111 if (procState > clientProcState) { 18112 procState = clientProcState; 18113 } 18114 if (client.curSchedGroup == Process.THREAD_GROUP_DEFAULT) { 18115 schedGroup = Process.THREAD_GROUP_DEFAULT; 18116 } 18117 } 18118 // If the provider has external (non-framework) process 18119 // dependencies, ensure that its adjustment is at least 18120 // FOREGROUND_APP_ADJ. 18121 if (cpr.hasExternalProcessHandles()) { 18122 if (adj > ProcessList.FOREGROUND_APP_ADJ) { 18123 adj = ProcessList.FOREGROUND_APP_ADJ; 18124 schedGroup = Process.THREAD_GROUP_DEFAULT; 18125 app.cached = false; 18126 app.adjType = "provider"; 18127 app.adjTarget = cpr.name; 18128 } 18129 if (procState > ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) { 18130 procState = ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 18131 } 18132 } 18133 } 18134 18135 if (mayBeTop && procState > ActivityManager.PROCESS_STATE_TOP) { 18136 // A client of one of our services or providers is in the top state. We 18137 // *may* want to be in the top state, but not if we are already running in 18138 // the background for some other reason. For the decision here, we are going 18139 // to pick out a few specific states that we want to remain in when a client 18140 // is top (states that tend to be longer-term) and otherwise allow it to go 18141 // to the top state. 18142 switch (procState) { 18143 case ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND: 18144 case ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND: 18145 case ActivityManager.PROCESS_STATE_SERVICE: 18146 // These all are longer-term states, so pull them up to the top 18147 // of the background states, but not all the way to the top state. 18148 procState = ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE; 18149 break; 18150 default: 18151 // Otherwise, top is a better choice, so take it. 18152 procState = ActivityManager.PROCESS_STATE_TOP; 18153 break; 18154 } 18155 } 18156 18157 if (procState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY) { 18158 if (app.hasClientActivities) { 18159 // This is a cached process, but with client activities. Mark it so. 18160 procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT; 18161 app.adjType = "cch-client-act"; 18162 } else if (app.treatLikeActivity) { 18163 // This is a cached process, but somebody wants us to treat it like it has 18164 // an activity, okay! 18165 procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY; 18166 app.adjType = "cch-as-act"; 18167 } 18168 } 18169 18170 if (adj == ProcessList.SERVICE_ADJ) { 18171 if (doingAll) { 18172 app.serviceb = mNewNumAServiceProcs > (mNumServiceProcs/3); 18173 mNewNumServiceProcs++; 18174 //Slog.i(TAG, "ADJ " + app + " serviceb=" + app.serviceb); 18175 if (!app.serviceb) { 18176 // This service isn't far enough down on the LRU list to 18177 // normally be a B service, but if we are low on RAM and it 18178 // is large we want to force it down since we would prefer to 18179 // keep launcher over it. 18180 if (mLastMemoryLevel > ProcessStats.ADJ_MEM_FACTOR_NORMAL 18181 && app.lastPss >= mProcessList.getCachedRestoreThresholdKb()) { 18182 app.serviceHighRam = true; 18183 app.serviceb = true; 18184 //Slog.i(TAG, "ADJ " + app + " high ram!"); 18185 } else { 18186 mNewNumAServiceProcs++; 18187 //Slog.i(TAG, "ADJ " + app + " not high ram!"); 18188 } 18189 } else { 18190 app.serviceHighRam = false; 18191 } 18192 } 18193 if (app.serviceb) { 18194 adj = ProcessList.SERVICE_B_ADJ; 18195 } 18196 } 18197 18198 app.curRawAdj = adj; 18199 18200 //Slog.i(TAG, "OOM ADJ " + app + ": pid=" + app.pid + 18201 // " adj=" + adj + " curAdj=" + app.curAdj + " maxAdj=" + app.maxAdj); 18202 if (adj > app.maxAdj) { 18203 adj = app.maxAdj; 18204 if (app.maxAdj <= ProcessList.PERCEPTIBLE_APP_ADJ) { 18205 schedGroup = Process.THREAD_GROUP_DEFAULT; 18206 } 18207 } 18208 18209 // Do final modification to adj. Everything we do between here and applying 18210 // the final setAdj must be done in this function, because we will also use 18211 // it when computing the final cached adj later. Note that we don't need to 18212 // worry about this for max adj above, since max adj will always be used to 18213 // keep it out of the cached vaues. 18214 app.curAdj = app.modifyRawOomAdj(adj); 18215 app.curSchedGroup = schedGroup; 18216 app.curProcState = procState; 18217 app.foregroundActivities = foregroundActivities; 18218 18219 return app.curRawAdj; 18220 } 18221 18222 /** 18223 * Record new PSS sample for a process. 18224 */ 18225 void recordPssSampleLocked(ProcessRecord proc, int procState, long pss, long uss, long now) { 18226 EventLogTags.writeAmPss(proc.pid, proc.uid, proc.processName, pss * 1024, uss * 1024); 18227 proc.lastPssTime = now; 18228 proc.baseProcessTracker.addPss(pss, uss, true, proc.pkgList); 18229 if (DEBUG_PSS) Slog.d(TAG_PSS, 18230 "PSS of " + proc.toShortString() + ": " + pss + " lastPss=" + proc.lastPss 18231 + " state=" + ProcessList.makeProcStateString(procState)); 18232 if (proc.initialIdlePss == 0) { 18233 proc.initialIdlePss = pss; 18234 } 18235 proc.lastPss = pss; 18236 if (procState >= ActivityManager.PROCESS_STATE_HOME) { 18237 proc.lastCachedPss = pss; 18238 } 18239 18240 final SparseArray<Pair<Long, String>> watchUids 18241 = mMemWatchProcesses.getMap().get(proc.processName); 18242 Long check = null; 18243 if (watchUids != null) { 18244 Pair<Long, String> val = watchUids.get(proc.uid); 18245 if (val == null) { 18246 val = watchUids.get(0); 18247 } 18248 if (val != null) { 18249 check = val.first; 18250 } 18251 } 18252 if (check != null) { 18253 if ((pss * 1024) >= check && proc.thread != null && mMemWatchDumpProcName == null) { 18254 boolean isDebuggable = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 18255 if (!isDebuggable) { 18256 if ((proc.info.flags&ApplicationInfo.FLAG_DEBUGGABLE) != 0) { 18257 isDebuggable = true; 18258 } 18259 } 18260 if (isDebuggable) { 18261 Slog.w(TAG, "Process " + proc + " exceeded pss limit " + check + "; reporting"); 18262 final ProcessRecord myProc = proc; 18263 final File heapdumpFile = DumpHeapProvider.getJavaFile(); 18264 mMemWatchDumpProcName = proc.processName; 18265 mMemWatchDumpFile = heapdumpFile.toString(); 18266 mMemWatchDumpPid = proc.pid; 18267 mMemWatchDumpUid = proc.uid; 18268 BackgroundThread.getHandler().post(new Runnable() { 18269 @Override 18270 public void run() { 18271 revokeUriPermission(ActivityThread.currentActivityThread() 18272 .getApplicationThread(), 18273 DumpHeapActivity.JAVA_URI, 18274 Intent.FLAG_GRANT_READ_URI_PERMISSION 18275 | Intent.FLAG_GRANT_WRITE_URI_PERMISSION, 18276 UserHandle.myUserId()); 18277 ParcelFileDescriptor fd = null; 18278 try { 18279 heapdumpFile.delete(); 18280 fd = ParcelFileDescriptor.open(heapdumpFile, 18281 ParcelFileDescriptor.MODE_CREATE | 18282 ParcelFileDescriptor.MODE_TRUNCATE | 18283 ParcelFileDescriptor.MODE_WRITE_ONLY | 18284 ParcelFileDescriptor.MODE_APPEND); 18285 IApplicationThread thread = myProc.thread; 18286 if (thread != null) { 18287 try { 18288 if (DEBUG_PSS) Slog.d(TAG_PSS, 18289 "Requesting dump heap from " 18290 + myProc + " to " + heapdumpFile); 18291 thread.dumpHeap(true, heapdumpFile.toString(), fd); 18292 } catch (RemoteException e) { 18293 } 18294 } 18295 } catch (FileNotFoundException e) { 18296 e.printStackTrace(); 18297 } finally { 18298 if (fd != null) { 18299 try { 18300 fd.close(); 18301 } catch (IOException e) { 18302 } 18303 } 18304 } 18305 } 18306 }); 18307 } else { 18308 Slog.w(TAG, "Process " + proc + " exceeded pss limit " + check 18309 + ", but debugging not enabled"); 18310 } 18311 } 18312 } 18313 } 18314 18315 /** 18316 * Schedule PSS collection of a process. 18317 */ 18318 void requestPssLocked(ProcessRecord proc, int procState) { 18319 if (mPendingPssProcesses.contains(proc)) { 18320 return; 18321 } 18322 if (mPendingPssProcesses.size() == 0) { 18323 mBgHandler.sendEmptyMessage(COLLECT_PSS_BG_MSG); 18324 } 18325 if (DEBUG_PSS) Slog.d(TAG_PSS, "Requesting PSS of: " + proc); 18326 proc.pssProcState = procState; 18327 mPendingPssProcesses.add(proc); 18328 } 18329 18330 /** 18331 * Schedule PSS collection of all processes. 18332 */ 18333 void requestPssAllProcsLocked(long now, boolean always, boolean memLowered) { 18334 if (!always) { 18335 if (now < (mLastFullPssTime + 18336 (memLowered ? FULL_PSS_LOWERED_INTERVAL : FULL_PSS_MIN_INTERVAL))) { 18337 return; 18338 } 18339 } 18340 if (DEBUG_PSS) Slog.d(TAG_PSS, "Requesting PSS of all procs! memLowered=" + memLowered); 18341 mLastFullPssTime = now; 18342 mFullPssPending = true; 18343 mPendingPssProcesses.ensureCapacity(mLruProcesses.size()); 18344 mPendingPssProcesses.clear(); 18345 for (int i = mLruProcesses.size() - 1; i >= 0; i--) { 18346 ProcessRecord app = mLruProcesses.get(i); 18347 if (app.thread == null 18348 || app.curProcState == ActivityManager.PROCESS_STATE_NONEXISTENT) { 18349 continue; 18350 } 18351 if (memLowered || now > (app.lastStateTime+ProcessList.PSS_ALL_INTERVAL)) { 18352 app.pssProcState = app.setProcState; 18353 app.nextPssTime = ProcessList.computeNextPssTime(app.curProcState, true, 18354 mTestPssMode, isSleeping(), now); 18355 mPendingPssProcesses.add(app); 18356 } 18357 } 18358 mBgHandler.sendEmptyMessage(COLLECT_PSS_BG_MSG); 18359 } 18360 18361 public void setTestPssMode(boolean enabled) { 18362 synchronized (this) { 18363 mTestPssMode = enabled; 18364 if (enabled) { 18365 // Whenever we enable the mode, we want to take a snapshot all of current 18366 // process mem use. 18367 requestPssAllProcsLocked(SystemClock.uptimeMillis(), true, true); 18368 } 18369 } 18370 } 18371 18372 /** 18373 * Ask a given process to GC right now. 18374 */ 18375 final void performAppGcLocked(ProcessRecord app) { 18376 try { 18377 app.lastRequestedGc = SystemClock.uptimeMillis(); 18378 if (app.thread != null) { 18379 if (app.reportLowMemory) { 18380 app.reportLowMemory = false; 18381 app.thread.scheduleLowMemory(); 18382 } else { 18383 app.thread.processInBackground(); 18384 } 18385 } 18386 } catch (Exception e) { 18387 // whatever. 18388 } 18389 } 18390 18391 /** 18392 * Returns true if things are idle enough to perform GCs. 18393 */ 18394 private final boolean canGcNowLocked() { 18395 boolean processingBroadcasts = false; 18396 for (BroadcastQueue q : mBroadcastQueues) { 18397 if (q.mParallelBroadcasts.size() != 0 || q.mOrderedBroadcasts.size() != 0) { 18398 processingBroadcasts = true; 18399 } 18400 } 18401 return !processingBroadcasts 18402 && (isSleeping() || mStackSupervisor.allResumedActivitiesIdle()); 18403 } 18404 18405 /** 18406 * Perform GCs on all processes that are waiting for it, but only 18407 * if things are idle. 18408 */ 18409 final void performAppGcsLocked() { 18410 final int N = mProcessesToGc.size(); 18411 if (N <= 0) { 18412 return; 18413 } 18414 if (canGcNowLocked()) { 18415 while (mProcessesToGc.size() > 0) { 18416 ProcessRecord proc = mProcessesToGc.remove(0); 18417 if (proc.curRawAdj > ProcessList.PERCEPTIBLE_APP_ADJ || proc.reportLowMemory) { 18418 if ((proc.lastRequestedGc+GC_MIN_INTERVAL) 18419 <= SystemClock.uptimeMillis()) { 18420 // To avoid spamming the system, we will GC processes one 18421 // at a time, waiting a few seconds between each. 18422 performAppGcLocked(proc); 18423 scheduleAppGcsLocked(); 18424 return; 18425 } else { 18426 // It hasn't been long enough since we last GCed this 18427 // process... put it in the list to wait for its time. 18428 addProcessToGcListLocked(proc); 18429 break; 18430 } 18431 } 18432 } 18433 18434 scheduleAppGcsLocked(); 18435 } 18436 } 18437 18438 /** 18439 * If all looks good, perform GCs on all processes waiting for them. 18440 */ 18441 final void performAppGcsIfAppropriateLocked() { 18442 if (canGcNowLocked()) { 18443 performAppGcsLocked(); 18444 return; 18445 } 18446 // Still not idle, wait some more. 18447 scheduleAppGcsLocked(); 18448 } 18449 18450 /** 18451 * Schedule the execution of all pending app GCs. 18452 */ 18453 final void scheduleAppGcsLocked() { 18454 mHandler.removeMessages(GC_BACKGROUND_PROCESSES_MSG); 18455 18456 if (mProcessesToGc.size() > 0) { 18457 // Schedule a GC for the time to the next process. 18458 ProcessRecord proc = mProcessesToGc.get(0); 18459 Message msg = mHandler.obtainMessage(GC_BACKGROUND_PROCESSES_MSG); 18460 18461 long when = proc.lastRequestedGc + GC_MIN_INTERVAL; 18462 long now = SystemClock.uptimeMillis(); 18463 if (when < (now+GC_TIMEOUT)) { 18464 when = now + GC_TIMEOUT; 18465 } 18466 mHandler.sendMessageAtTime(msg, when); 18467 } 18468 } 18469 18470 /** 18471 * Add a process to the array of processes waiting to be GCed. Keeps the 18472 * list in sorted order by the last GC time. The process can't already be 18473 * on the list. 18474 */ 18475 final void addProcessToGcListLocked(ProcessRecord proc) { 18476 boolean added = false; 18477 for (int i=mProcessesToGc.size()-1; i>=0; i--) { 18478 if (mProcessesToGc.get(i).lastRequestedGc < 18479 proc.lastRequestedGc) { 18480 added = true; 18481 mProcessesToGc.add(i+1, proc); 18482 break; 18483 } 18484 } 18485 if (!added) { 18486 mProcessesToGc.add(0, proc); 18487 } 18488 } 18489 18490 /** 18491 * Set up to ask a process to GC itself. This will either do it 18492 * immediately, or put it on the list of processes to gc the next 18493 * time things are idle. 18494 */ 18495 final void scheduleAppGcLocked(ProcessRecord app) { 18496 long now = SystemClock.uptimeMillis(); 18497 if ((app.lastRequestedGc+GC_MIN_INTERVAL) > now) { 18498 return; 18499 } 18500 if (!mProcessesToGc.contains(app)) { 18501 addProcessToGcListLocked(app); 18502 scheduleAppGcsLocked(); 18503 } 18504 } 18505 18506 final void checkExcessivePowerUsageLocked(boolean doKills) { 18507 updateCpuStatsNow(); 18508 18509 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 18510 boolean doWakeKills = doKills; 18511 boolean doCpuKills = doKills; 18512 if (mLastPowerCheckRealtime == 0) { 18513 doWakeKills = false; 18514 } 18515 if (mLastPowerCheckUptime == 0) { 18516 doCpuKills = false; 18517 } 18518 if (stats.isScreenOn()) { 18519 doWakeKills = false; 18520 } 18521 final long curRealtime = SystemClock.elapsedRealtime(); 18522 final long realtimeSince = curRealtime - mLastPowerCheckRealtime; 18523 final long curUptime = SystemClock.uptimeMillis(); 18524 final long uptimeSince = curUptime - mLastPowerCheckUptime; 18525 mLastPowerCheckRealtime = curRealtime; 18526 mLastPowerCheckUptime = curUptime; 18527 if (realtimeSince < WAKE_LOCK_MIN_CHECK_DURATION) { 18528 doWakeKills = false; 18529 } 18530 if (uptimeSince < CPU_MIN_CHECK_DURATION) { 18531 doCpuKills = false; 18532 } 18533 int i = mLruProcesses.size(); 18534 while (i > 0) { 18535 i--; 18536 ProcessRecord app = mLruProcesses.get(i); 18537 if (app.setProcState >= ActivityManager.PROCESS_STATE_HOME) { 18538 long wtime; 18539 synchronized (stats) { 18540 wtime = stats.getProcessWakeTime(app.info.uid, 18541 app.pid, curRealtime); 18542 } 18543 long wtimeUsed = wtime - app.lastWakeTime; 18544 long cputimeUsed = app.curCpuTime - app.lastCpuTime; 18545 if (DEBUG_POWER) { 18546 StringBuilder sb = new StringBuilder(128); 18547 sb.append("Wake for "); 18548 app.toShortString(sb); 18549 sb.append(": over "); 18550 TimeUtils.formatDuration(realtimeSince, sb); 18551 sb.append(" used "); 18552 TimeUtils.formatDuration(wtimeUsed, sb); 18553 sb.append(" ("); 18554 sb.append((wtimeUsed*100)/realtimeSince); 18555 sb.append("%)"); 18556 Slog.i(TAG_POWER, sb.toString()); 18557 sb.setLength(0); 18558 sb.append("CPU for "); 18559 app.toShortString(sb); 18560 sb.append(": over "); 18561 TimeUtils.formatDuration(uptimeSince, sb); 18562 sb.append(" used "); 18563 TimeUtils.formatDuration(cputimeUsed, sb); 18564 sb.append(" ("); 18565 sb.append((cputimeUsed*100)/uptimeSince); 18566 sb.append("%)"); 18567 Slog.i(TAG_POWER, sb.toString()); 18568 } 18569 // If a process has held a wake lock for more 18570 // than 50% of the time during this period, 18571 // that sounds bad. Kill! 18572 if (doWakeKills && realtimeSince > 0 18573 && ((wtimeUsed*100)/realtimeSince) >= 50) { 18574 synchronized (stats) { 18575 stats.reportExcessiveWakeLocked(app.info.uid, app.processName, 18576 realtimeSince, wtimeUsed); 18577 } 18578 app.kill("excessive wake held " + wtimeUsed + " during " + realtimeSince, true); 18579 app.baseProcessTracker.reportExcessiveWake(app.pkgList); 18580 } else if (doCpuKills && uptimeSince > 0 18581 && ((cputimeUsed*100)/uptimeSince) >= 25) { 18582 synchronized (stats) { 18583 stats.reportExcessiveCpuLocked(app.info.uid, app.processName, 18584 uptimeSince, cputimeUsed); 18585 } 18586 app.kill("excessive cpu " + cputimeUsed + " during " + uptimeSince, true); 18587 app.baseProcessTracker.reportExcessiveCpu(app.pkgList); 18588 } else { 18589 app.lastWakeTime = wtime; 18590 app.lastCpuTime = app.curCpuTime; 18591 } 18592 } 18593 } 18594 } 18595 18596 private final boolean applyOomAdjLocked(ProcessRecord app, boolean doingAll, long now) { 18597 boolean success = true; 18598 18599 if (app.curRawAdj != app.setRawAdj) { 18600 app.setRawAdj = app.curRawAdj; 18601 } 18602 18603 int changes = 0; 18604 18605 if (app.curAdj != app.setAdj) { 18606 ProcessList.setOomAdj(app.pid, app.info.uid, app.curAdj); 18607 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 18608 "Set " + app.pid + " " + app.processName + " adj " + app.curAdj + ": " 18609 + app.adjType); 18610 app.setAdj = app.curAdj; 18611 } 18612 18613 if (app.setSchedGroup != app.curSchedGroup) { 18614 app.setSchedGroup = app.curSchedGroup; 18615 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 18616 "Setting process group of " + app.processName 18617 + " to " + app.curSchedGroup); 18618 if (app.waitingToKill != null && app.curReceiver == null 18619 && app.setSchedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE) { 18620 app.kill(app.waitingToKill, true); 18621 success = false; 18622 } else { 18623 if (true) { 18624 long oldId = Binder.clearCallingIdentity(); 18625 try { 18626 Process.setProcessGroup(app.pid, app.curSchedGroup); 18627 } catch (Exception e) { 18628 Slog.w(TAG, "Failed setting process group of " + app.pid 18629 + " to " + app.curSchedGroup); 18630 e.printStackTrace(); 18631 } finally { 18632 Binder.restoreCallingIdentity(oldId); 18633 } 18634 } else { 18635 if (app.thread != null) { 18636 try { 18637 app.thread.setSchedulingGroup(app.curSchedGroup); 18638 } catch (RemoteException e) { 18639 } 18640 } 18641 } 18642 Process.setSwappiness(app.pid, 18643 app.curSchedGroup <= Process.THREAD_GROUP_BG_NONINTERACTIVE); 18644 } 18645 } 18646 if (app.repForegroundActivities != app.foregroundActivities) { 18647 app.repForegroundActivities = app.foregroundActivities; 18648 changes |= ProcessChangeItem.CHANGE_ACTIVITIES; 18649 } 18650 if (app.repProcState != app.curProcState) { 18651 app.repProcState = app.curProcState; 18652 changes |= ProcessChangeItem.CHANGE_PROCESS_STATE; 18653 if (app.thread != null) { 18654 try { 18655 if (false) { 18656 //RuntimeException h = new RuntimeException("here"); 18657 Slog.i(TAG, "Sending new process state " + app.repProcState 18658 + " to " + app /*, h*/); 18659 } 18660 app.thread.setProcessState(app.repProcState); 18661 } catch (RemoteException e) { 18662 } 18663 } 18664 } 18665 if (app.setProcState == ActivityManager.PROCESS_STATE_NONEXISTENT 18666 || ProcessList.procStatesDifferForMem(app.curProcState, app.setProcState)) { 18667 if (false && mTestPssMode && app.setProcState >= 0 && app.lastStateTime <= (now-200)) { 18668 // Experimental code to more aggressively collect pss while 18669 // running test... the problem is that this tends to collect 18670 // the data right when a process is transitioning between process 18671 // states, which well tend to give noisy data. 18672 long start = SystemClock.uptimeMillis(); 18673 long pss = Debug.getPss(app.pid, mTmpLong, null); 18674 recordPssSampleLocked(app, app.curProcState, pss, mTmpLong[0], now); 18675 mPendingPssProcesses.remove(app); 18676 Slog.i(TAG, "Recorded pss for " + app + " state " + app.setProcState 18677 + " to " + app.curProcState + ": " 18678 + (SystemClock.uptimeMillis()-start) + "ms"); 18679 } 18680 app.lastStateTime = now; 18681 app.nextPssTime = ProcessList.computeNextPssTime(app.curProcState, true, 18682 mTestPssMode, isSleeping(), now); 18683 if (DEBUG_PSS) Slog.d(TAG_PSS, "Process state change from " 18684 + ProcessList.makeProcStateString(app.setProcState) + " to " 18685 + ProcessList.makeProcStateString(app.curProcState) + " next pss in " 18686 + (app.nextPssTime-now) + ": " + app); 18687 } else { 18688 if (now > app.nextPssTime || (now > (app.lastPssTime+ProcessList.PSS_MAX_INTERVAL) 18689 && now > (app.lastStateTime+ProcessList.minTimeFromStateChange( 18690 mTestPssMode)))) { 18691 requestPssLocked(app, app.setProcState); 18692 app.nextPssTime = ProcessList.computeNextPssTime(app.curProcState, false, 18693 mTestPssMode, isSleeping(), now); 18694 } else if (false && DEBUG_PSS) Slog.d(TAG_PSS, 18695 "Not requesting PSS of " + app + ": next=" + (app.nextPssTime-now)); 18696 } 18697 if (app.setProcState != app.curProcState) { 18698 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 18699 "Proc state change of " + app.processName 18700 + " to " + app.curProcState); 18701 boolean setImportant = app.setProcState < ActivityManager.PROCESS_STATE_SERVICE; 18702 boolean curImportant = app.curProcState < ActivityManager.PROCESS_STATE_SERVICE; 18703 if (setImportant && !curImportant) { 18704 // This app is no longer something we consider important enough to allow to 18705 // use arbitrary amounts of battery power. Note 18706 // its current wake lock time to later know to kill it if 18707 // it is not behaving well. 18708 BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); 18709 synchronized (stats) { 18710 app.lastWakeTime = stats.getProcessWakeTime(app.info.uid, 18711 app.pid, SystemClock.elapsedRealtime()); 18712 } 18713 app.lastCpuTime = app.curCpuTime; 18714 18715 } 18716 // Inform UsageStats of important process state change 18717 // Must be called before updating setProcState 18718 maybeUpdateUsageStatsLocked(app); 18719 18720 app.setProcState = app.curProcState; 18721 if (app.setProcState >= ActivityManager.PROCESS_STATE_HOME) { 18722 app.notCachedSinceIdle = false; 18723 } 18724 if (!doingAll) { 18725 setProcessTrackerStateLocked(app, mProcessStats.getMemFactorLocked(), now); 18726 } else { 18727 app.procStateChanged = true; 18728 } 18729 } 18730 18731 if (changes != 0) { 18732 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18733 "Changes in " + app + ": " + changes); 18734 int i = mPendingProcessChanges.size()-1; 18735 ProcessChangeItem item = null; 18736 while (i >= 0) { 18737 item = mPendingProcessChanges.get(i); 18738 if (item.pid == app.pid) { 18739 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18740 "Re-using existing item: " + item); 18741 break; 18742 } 18743 i--; 18744 } 18745 if (i < 0) { 18746 // No existing item in pending changes; need a new one. 18747 final int NA = mAvailProcessChanges.size(); 18748 if (NA > 0) { 18749 item = mAvailProcessChanges.remove(NA-1); 18750 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18751 "Retrieving available item: " + item); 18752 } else { 18753 item = new ProcessChangeItem(); 18754 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18755 "Allocating new item: " + item); 18756 } 18757 item.changes = 0; 18758 item.pid = app.pid; 18759 item.uid = app.info.uid; 18760 if (mPendingProcessChanges.size() == 0) { 18761 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18762 "*** Enqueueing dispatch processes changed!"); 18763 mUiHandler.obtainMessage(DISPATCH_PROCESSES_CHANGED).sendToTarget(); 18764 } 18765 mPendingProcessChanges.add(item); 18766 } 18767 item.changes |= changes; 18768 item.processState = app.repProcState; 18769 item.foregroundActivities = app.repForegroundActivities; 18770 if (DEBUG_PROCESS_OBSERVERS) Slog.i(TAG_PROCESS_OBSERVERS, 18771 "Item " + Integer.toHexString(System.identityHashCode(item)) 18772 + " " + app.toShortString() + ": changes=" + item.changes 18773 + " procState=" + item.processState 18774 + " foreground=" + item.foregroundActivities 18775 + " type=" + app.adjType + " source=" + app.adjSource 18776 + " target=" + app.adjTarget); 18777 } 18778 18779 return success; 18780 } 18781 18782 private final void enqueueUidChangeLocked(UidRecord uidRec, boolean gone) { 18783 if (uidRec.pendingChange == null) { 18784 if (mPendingUidChanges.size() == 0) { 18785 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 18786 "*** Enqueueing dispatch uid changed!"); 18787 mUiHandler.obtainMessage(DISPATCH_UIDS_CHANGED_MSG).sendToTarget(); 18788 } 18789 final int NA = mAvailUidChanges.size(); 18790 if (NA > 0) { 18791 uidRec.pendingChange = mAvailUidChanges.remove(NA-1); 18792 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 18793 "Retrieving available item: " + uidRec.pendingChange); 18794 } else { 18795 uidRec.pendingChange = new UidRecord.ChangeItem(); 18796 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 18797 "Allocating new item: " + uidRec.pendingChange); 18798 } 18799 uidRec.pendingChange.uidRecord = uidRec; 18800 uidRec.pendingChange.uid = uidRec.uid; 18801 mPendingUidChanges.add(uidRec.pendingChange); 18802 } 18803 uidRec.pendingChange.gone = gone; 18804 uidRec.pendingChange.processState = uidRec.setProcState; 18805 } 18806 18807 private void maybeUpdateProviderUsageStatsLocked(ProcessRecord app, String providerPkgName, 18808 String authority) { 18809 if (app == null) return; 18810 if (app.curProcState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND) { 18811 UserState userState = mStartedUsers.get(app.userId); 18812 if (userState == null) return; 18813 final long now = SystemClock.elapsedRealtime(); 18814 Long lastReported = userState.mProviderLastReportedFg.get(authority); 18815 if (lastReported == null || lastReported < now - 60 * 1000L) { 18816 mUsageStatsService.reportContentProviderUsage( 18817 authority, providerPkgName, app.userId); 18818 userState.mProviderLastReportedFg.put(authority, now); 18819 } 18820 } 18821 } 18822 18823 private void maybeUpdateUsageStatsLocked(ProcessRecord app) { 18824 if (DEBUG_USAGE_STATS) { 18825 Slog.d(TAG, "Checking proc [" + Arrays.toString(app.getPackageList()) 18826 + "] state changes: old = " + app.setProcState + ", new = " 18827 + app.curProcState); 18828 } 18829 if (mUsageStatsService == null) { 18830 return; 18831 } 18832 boolean isInteraction; 18833 // To avoid some abuse patterns, we are going to be careful about what we consider 18834 // to be an app interaction. Being the top activity doesn't count while the display 18835 // is sleeping, nor do short foreground services. 18836 if (app.curProcState <= ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE) { 18837 isInteraction = true; 18838 app.fgInteractionTime = 0; 18839 } else if (app.curProcState <= ActivityManager.PROCESS_STATE_TOP_SLEEPING) { 18840 final long now = SystemClock.elapsedRealtime(); 18841 if (app.fgInteractionTime == 0) { 18842 app.fgInteractionTime = now; 18843 isInteraction = false; 18844 } else { 18845 isInteraction = now > app.fgInteractionTime + SERVICE_USAGE_INTERACTION_TIME; 18846 } 18847 } else { 18848 isInteraction = app.curProcState 18849 <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 18850 app.fgInteractionTime = 0; 18851 } 18852 if (isInteraction && !app.reportedInteraction) { 18853 String[] packages = app.getPackageList(); 18854 if (packages != null) { 18855 for (int i = 0; i < packages.length; i++) { 18856 mUsageStatsService.reportEvent(packages[i], app.userId, 18857 UsageEvents.Event.SYSTEM_INTERACTION); 18858 } 18859 } 18860 } 18861 app.reportedInteraction = isInteraction; 18862 } 18863 18864 private final void setProcessTrackerStateLocked(ProcessRecord proc, int memFactor, long now) { 18865 if (proc.thread != null) { 18866 if (proc.baseProcessTracker != null) { 18867 proc.baseProcessTracker.setState(proc.repProcState, memFactor, now, proc.pkgList); 18868 } 18869 if (proc.repProcState >= 0) { 18870 mBatteryStatsService.noteProcessState(proc.processName, proc.info.uid, 18871 proc.repProcState); 18872 } 18873 } 18874 } 18875 18876 private final boolean updateOomAdjLocked(ProcessRecord app, int cachedAdj, 18877 ProcessRecord TOP_APP, boolean doingAll, long now) { 18878 if (app.thread == null) { 18879 return false; 18880 } 18881 18882 computeOomAdjLocked(app, cachedAdj, TOP_APP, doingAll, now); 18883 18884 return applyOomAdjLocked(app, doingAll, now); 18885 } 18886 18887 final void updateProcessForegroundLocked(ProcessRecord proc, boolean isForeground, 18888 boolean oomAdj) { 18889 if (isForeground != proc.foregroundServices) { 18890 proc.foregroundServices = isForeground; 18891 ArrayList<ProcessRecord> curProcs = mForegroundPackages.get(proc.info.packageName, 18892 proc.info.uid); 18893 if (isForeground) { 18894 if (curProcs == null) { 18895 curProcs = new ArrayList<ProcessRecord>(); 18896 mForegroundPackages.put(proc.info.packageName, proc.info.uid, curProcs); 18897 } 18898 if (!curProcs.contains(proc)) { 18899 curProcs.add(proc); 18900 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_FOREGROUND_START, 18901 proc.info.packageName, proc.info.uid); 18902 } 18903 } else { 18904 if (curProcs != null) { 18905 if (curProcs.remove(proc)) { 18906 mBatteryStatsService.noteEvent( 18907 BatteryStats.HistoryItem.EVENT_FOREGROUND_FINISH, 18908 proc.info.packageName, proc.info.uid); 18909 if (curProcs.size() <= 0) { 18910 mForegroundPackages.remove(proc.info.packageName, proc.info.uid); 18911 } 18912 } 18913 } 18914 } 18915 if (oomAdj) { 18916 updateOomAdjLocked(); 18917 } 18918 } 18919 } 18920 18921 private final ActivityRecord resumedAppLocked() { 18922 ActivityRecord act = mStackSupervisor.resumedAppLocked(); 18923 String pkg; 18924 int uid; 18925 if (act != null) { 18926 pkg = act.packageName; 18927 uid = act.info.applicationInfo.uid; 18928 } else { 18929 pkg = null; 18930 uid = -1; 18931 } 18932 // Has the UID or resumed package name changed? 18933 if (uid != mCurResumedUid || (pkg != mCurResumedPackage 18934 && (pkg == null || !pkg.equals(mCurResumedPackage)))) { 18935 if (mCurResumedPackage != null) { 18936 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_TOP_FINISH, 18937 mCurResumedPackage, mCurResumedUid); 18938 } 18939 mCurResumedPackage = pkg; 18940 mCurResumedUid = uid; 18941 if (mCurResumedPackage != null) { 18942 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_TOP_START, 18943 mCurResumedPackage, mCurResumedUid); 18944 } 18945 } 18946 return act; 18947 } 18948 18949 final boolean updateOomAdjLocked(ProcessRecord app) { 18950 final ActivityRecord TOP_ACT = resumedAppLocked(); 18951 final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; 18952 final boolean wasCached = app.cached; 18953 18954 mAdjSeq++; 18955 18956 // This is the desired cached adjusment we want to tell it to use. 18957 // If our app is currently cached, we know it, and that is it. Otherwise, 18958 // we don't know it yet, and it needs to now be cached we will then 18959 // need to do a complete oom adj. 18960 final int cachedAdj = app.curRawAdj >= ProcessList.CACHED_APP_MIN_ADJ 18961 ? app.curRawAdj : ProcessList.UNKNOWN_ADJ; 18962 boolean success = updateOomAdjLocked(app, cachedAdj, TOP_APP, false, 18963 SystemClock.uptimeMillis()); 18964 if (wasCached != app.cached || app.curRawAdj == ProcessList.UNKNOWN_ADJ) { 18965 // Changed to/from cached state, so apps after it in the LRU 18966 // list may also be changed. 18967 updateOomAdjLocked(); 18968 } 18969 return success; 18970 } 18971 18972 final void updateOomAdjLocked() { 18973 final ActivityRecord TOP_ACT = resumedAppLocked(); 18974 final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; 18975 final long now = SystemClock.uptimeMillis(); 18976 final long oldTime = now - ProcessList.MAX_EMPTY_TIME; 18977 final int N = mLruProcesses.size(); 18978 18979 if (false) { 18980 RuntimeException e = new RuntimeException(); 18981 e.fillInStackTrace(); 18982 Slog.i(TAG, "updateOomAdj: top=" + TOP_ACT, e); 18983 } 18984 18985 // Reset state in all uid records. 18986 for (int i=mActiveUids.size()-1; i>=0; i--) { 18987 final UidRecord uidRec = mActiveUids.valueAt(i); 18988 if (false && DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 18989 "Starting update of " + uidRec); 18990 uidRec.reset(); 18991 } 18992 18993 mAdjSeq++; 18994 mNewNumServiceProcs = 0; 18995 mNewNumAServiceProcs = 0; 18996 18997 final int emptyProcessLimit; 18998 final int cachedProcessLimit; 18999 if (mProcessLimit <= 0) { 19000 emptyProcessLimit = cachedProcessLimit = 0; 19001 } else if (mProcessLimit == 1) { 19002 emptyProcessLimit = 1; 19003 cachedProcessLimit = 0; 19004 } else { 19005 emptyProcessLimit = ProcessList.computeEmptyProcessLimit(mProcessLimit); 19006 cachedProcessLimit = mProcessLimit - emptyProcessLimit; 19007 } 19008 19009 // Let's determine how many processes we have running vs. 19010 // how many slots we have for background processes; we may want 19011 // to put multiple processes in a slot of there are enough of 19012 // them. 19013 int numSlots = (ProcessList.CACHED_APP_MAX_ADJ 19014 - ProcessList.CACHED_APP_MIN_ADJ + 1) / 2; 19015 int numEmptyProcs = N - mNumNonCachedProcs - mNumCachedHiddenProcs; 19016 if (numEmptyProcs > cachedProcessLimit) { 19017 // If there are more empty processes than our limit on cached 19018 // processes, then use the cached process limit for the factor. 19019 // This ensures that the really old empty processes get pushed 19020 // down to the bottom, so if we are running low on memory we will 19021 // have a better chance at keeping around more cached processes 19022 // instead of a gazillion empty processes. 19023 numEmptyProcs = cachedProcessLimit; 19024 } 19025 int emptyFactor = numEmptyProcs/numSlots; 19026 if (emptyFactor < 1) emptyFactor = 1; 19027 int cachedFactor = (mNumCachedHiddenProcs > 0 ? mNumCachedHiddenProcs : 1)/numSlots; 19028 if (cachedFactor < 1) cachedFactor = 1; 19029 int stepCached = 0; 19030 int stepEmpty = 0; 19031 int numCached = 0; 19032 int numEmpty = 0; 19033 int numTrimming = 0; 19034 19035 mNumNonCachedProcs = 0; 19036 mNumCachedHiddenProcs = 0; 19037 19038 // First update the OOM adjustment for each of the 19039 // application processes based on their current state. 19040 int curCachedAdj = ProcessList.CACHED_APP_MIN_ADJ; 19041 int nextCachedAdj = curCachedAdj+1; 19042 int curEmptyAdj = ProcessList.CACHED_APP_MIN_ADJ; 19043 int nextEmptyAdj = curEmptyAdj+2; 19044 for (int i=N-1; i>=0; i--) { 19045 ProcessRecord app = mLruProcesses.get(i); 19046 if (!app.killedByAm && app.thread != null) { 19047 app.procStateChanged = false; 19048 computeOomAdjLocked(app, ProcessList.UNKNOWN_ADJ, TOP_APP, true, now); 19049 19050 // If we haven't yet assigned the final cached adj 19051 // to the process, do that now. 19052 if (app.curAdj >= ProcessList.UNKNOWN_ADJ) { 19053 switch (app.curProcState) { 19054 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY: 19055 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT: 19056 // This process is a cached process holding activities... 19057 // assign it the next cached value for that type, and then 19058 // step that cached level. 19059 app.curRawAdj = curCachedAdj; 19060 app.curAdj = app.modifyRawOomAdj(curCachedAdj); 19061 if (DEBUG_LRU && false) Slog.d(TAG_LRU, "Assigning activity LRU #" + i 19062 + " adj: " + app.curAdj + " (curCachedAdj=" + curCachedAdj 19063 + ")"); 19064 if (curCachedAdj != nextCachedAdj) { 19065 stepCached++; 19066 if (stepCached >= cachedFactor) { 19067 stepCached = 0; 19068 curCachedAdj = nextCachedAdj; 19069 nextCachedAdj += 2; 19070 if (nextCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) { 19071 nextCachedAdj = ProcessList.CACHED_APP_MAX_ADJ; 19072 } 19073 } 19074 } 19075 break; 19076 default: 19077 // For everything else, assign next empty cached process 19078 // level and bump that up. Note that this means that 19079 // long-running services that have dropped down to the 19080 // cached level will be treated as empty (since their process 19081 // state is still as a service), which is what we want. 19082 app.curRawAdj = curEmptyAdj; 19083 app.curAdj = app.modifyRawOomAdj(curEmptyAdj); 19084 if (DEBUG_LRU && false) Slog.d(TAG_LRU, "Assigning empty LRU #" + i 19085 + " adj: " + app.curAdj + " (curEmptyAdj=" + curEmptyAdj 19086 + ")"); 19087 if (curEmptyAdj != nextEmptyAdj) { 19088 stepEmpty++; 19089 if (stepEmpty >= emptyFactor) { 19090 stepEmpty = 0; 19091 curEmptyAdj = nextEmptyAdj; 19092 nextEmptyAdj += 2; 19093 if (nextEmptyAdj > ProcessList.CACHED_APP_MAX_ADJ) { 19094 nextEmptyAdj = ProcessList.CACHED_APP_MAX_ADJ; 19095 } 19096 } 19097 } 19098 break; 19099 } 19100 } 19101 19102 applyOomAdjLocked(app, true, now); 19103 19104 // Count the number of process types. 19105 switch (app.curProcState) { 19106 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY: 19107 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT: 19108 mNumCachedHiddenProcs++; 19109 numCached++; 19110 if (numCached > cachedProcessLimit) { 19111 app.kill("cached #" + numCached, true); 19112 } 19113 break; 19114 case ActivityManager.PROCESS_STATE_CACHED_EMPTY: 19115 if (numEmpty > ProcessList.TRIM_EMPTY_APPS 19116 && app.lastActivityTime < oldTime) { 19117 app.kill("empty for " 19118 + ((oldTime + ProcessList.MAX_EMPTY_TIME - app.lastActivityTime) 19119 / 1000) + "s", true); 19120 } else { 19121 numEmpty++; 19122 if (numEmpty > emptyProcessLimit) { 19123 app.kill("empty #" + numEmpty, true); 19124 } 19125 } 19126 break; 19127 default: 19128 mNumNonCachedProcs++; 19129 break; 19130 } 19131 19132 if (app.isolated && app.services.size() <= 0) { 19133 // If this is an isolated process, and there are no 19134 // services running in it, then the process is no longer 19135 // needed. We agressively kill these because we can by 19136 // definition not re-use the same process again, and it is 19137 // good to avoid having whatever code was running in them 19138 // left sitting around after no longer needed. 19139 app.kill("isolated not needed", true); 19140 } else { 19141 // Keeping this process, update its uid. 19142 final UidRecord uidRec = app.uidRecord; 19143 if (uidRec != null && uidRec.curProcState > app.curProcState) { 19144 uidRec.curProcState = app.curProcState; 19145 } 19146 } 19147 19148 if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME 19149 && !app.killedByAm) { 19150 numTrimming++; 19151 } 19152 } 19153 } 19154 19155 mNumServiceProcs = mNewNumServiceProcs; 19156 19157 // Now determine the memory trimming level of background processes. 19158 // Unfortunately we need to start at the back of the list to do this 19159 // properly. We only do this if the number of background apps we 19160 // are managing to keep around is less than half the maximum we desire; 19161 // if we are keeping a good number around, we'll let them use whatever 19162 // memory they want. 19163 final int numCachedAndEmpty = numCached + numEmpty; 19164 int memFactor; 19165 if (numCached <= ProcessList.TRIM_CACHED_APPS 19166 && numEmpty <= ProcessList.TRIM_EMPTY_APPS) { 19167 if (numCachedAndEmpty <= ProcessList.TRIM_CRITICAL_THRESHOLD) { 19168 memFactor = ProcessStats.ADJ_MEM_FACTOR_CRITICAL; 19169 } else if (numCachedAndEmpty <= ProcessList.TRIM_LOW_THRESHOLD) { 19170 memFactor = ProcessStats.ADJ_MEM_FACTOR_LOW; 19171 } else { 19172 memFactor = ProcessStats.ADJ_MEM_FACTOR_MODERATE; 19173 } 19174 } else { 19175 memFactor = ProcessStats.ADJ_MEM_FACTOR_NORMAL; 19176 } 19177 // We always allow the memory level to go up (better). We only allow it to go 19178 // down if we are in a state where that is allowed, *and* the total number of processes 19179 // has gone down since last time. 19180 if (DEBUG_OOM_ADJ) Slog.d(TAG_OOM_ADJ, "oom: memFactor=" + memFactor 19181 + " last=" + mLastMemoryLevel + " allowLow=" + mAllowLowerMemLevel 19182 + " numProcs=" + mLruProcesses.size() + " last=" + mLastNumProcesses); 19183 if (memFactor > mLastMemoryLevel) { 19184 if (!mAllowLowerMemLevel || mLruProcesses.size() >= mLastNumProcesses) { 19185 memFactor = mLastMemoryLevel; 19186 if (DEBUG_OOM_ADJ) Slog.d(TAG_OOM_ADJ, "Keeping last mem factor!"); 19187 } 19188 } 19189 mLastMemoryLevel = memFactor; 19190 mLastNumProcesses = mLruProcesses.size(); 19191 boolean allChanged = mProcessStats.setMemFactorLocked(memFactor, !isSleeping(), now); 19192 final int trackerMemFactor = mProcessStats.getMemFactorLocked(); 19193 if (memFactor != ProcessStats.ADJ_MEM_FACTOR_NORMAL) { 19194 if (mLowRamStartTime == 0) { 19195 mLowRamStartTime = now; 19196 } 19197 int step = 0; 19198 int fgTrimLevel; 19199 switch (memFactor) { 19200 case ProcessStats.ADJ_MEM_FACTOR_CRITICAL: 19201 fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL; 19202 break; 19203 case ProcessStats.ADJ_MEM_FACTOR_LOW: 19204 fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW; 19205 break; 19206 default: 19207 fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE; 19208 break; 19209 } 19210 int factor = numTrimming/3; 19211 int minFactor = 2; 19212 if (mHomeProcess != null) minFactor++; 19213 if (mPreviousProcess != null) minFactor++; 19214 if (factor < minFactor) factor = minFactor; 19215 int curLevel = ComponentCallbacks2.TRIM_MEMORY_COMPLETE; 19216 for (int i=N-1; i>=0; i--) { 19217 ProcessRecord app = mLruProcesses.get(i); 19218 if (allChanged || app.procStateChanged) { 19219 setProcessTrackerStateLocked(app, trackerMemFactor, now); 19220 app.procStateChanged = false; 19221 } 19222 if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME 19223 && !app.killedByAm) { 19224 if (app.trimMemoryLevel < curLevel && app.thread != null) { 19225 try { 19226 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 19227 "Trimming memory of " + app.processName + " to " + curLevel); 19228 app.thread.scheduleTrimMemory(curLevel); 19229 } catch (RemoteException e) { 19230 } 19231 if (false) { 19232 // For now we won't do this; our memory trimming seems 19233 // to be good enough at this point that destroying 19234 // activities causes more harm than good. 19235 if (curLevel >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE 19236 && app != mHomeProcess && app != mPreviousProcess) { 19237 // Need to do this on its own message because the stack may not 19238 // be in a consistent state at this point. 19239 // For these apps we will also finish their activities 19240 // to help them free memory. 19241 mStackSupervisor.scheduleDestroyAllActivities(app, "trim"); 19242 } 19243 } 19244 } 19245 app.trimMemoryLevel = curLevel; 19246 step++; 19247 if (step >= factor) { 19248 step = 0; 19249 switch (curLevel) { 19250 case ComponentCallbacks2.TRIM_MEMORY_COMPLETE: 19251 curLevel = ComponentCallbacks2.TRIM_MEMORY_MODERATE; 19252 break; 19253 case ComponentCallbacks2.TRIM_MEMORY_MODERATE: 19254 curLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND; 19255 break; 19256 } 19257 } 19258 } else if (app.curProcState == ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) { 19259 if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_BACKGROUND 19260 && app.thread != null) { 19261 try { 19262 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 19263 "Trimming memory of heavy-weight " + app.processName 19264 + " to " + ComponentCallbacks2.TRIM_MEMORY_BACKGROUND); 19265 app.thread.scheduleTrimMemory( 19266 ComponentCallbacks2.TRIM_MEMORY_BACKGROUND); 19267 } catch (RemoteException e) { 19268 } 19269 } 19270 app.trimMemoryLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND; 19271 } else { 19272 if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND 19273 || app.systemNoUi) && app.pendingUiClean) { 19274 // If this application is now in the background and it 19275 // had done UI, then give it the special trim level to 19276 // have it free UI resources. 19277 final int level = ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN; 19278 if (app.trimMemoryLevel < level && app.thread != null) { 19279 try { 19280 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 19281 "Trimming memory of bg-ui " + app.processName 19282 + " to " + level); 19283 app.thread.scheduleTrimMemory(level); 19284 } catch (RemoteException e) { 19285 } 19286 } 19287 app.pendingUiClean = false; 19288 } 19289 if (app.trimMemoryLevel < fgTrimLevel && app.thread != null) { 19290 try { 19291 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 19292 "Trimming memory of fg " + app.processName 19293 + " to " + fgTrimLevel); 19294 app.thread.scheduleTrimMemory(fgTrimLevel); 19295 } catch (RemoteException e) { 19296 } 19297 } 19298 app.trimMemoryLevel = fgTrimLevel; 19299 } 19300 } 19301 } else { 19302 if (mLowRamStartTime != 0) { 19303 mLowRamTimeSinceLastIdle += now - mLowRamStartTime; 19304 mLowRamStartTime = 0; 19305 } 19306 for (int i=N-1; i>=0; i--) { 19307 ProcessRecord app = mLruProcesses.get(i); 19308 if (allChanged || app.procStateChanged) { 19309 setProcessTrackerStateLocked(app, trackerMemFactor, now); 19310 app.procStateChanged = false; 19311 } 19312 if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND 19313 || app.systemNoUi) && app.pendingUiClean) { 19314 if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN 19315 && app.thread != null) { 19316 try { 19317 if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ, 19318 "Trimming memory of ui hidden " + app.processName 19319 + " to " + ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN); 19320 app.thread.scheduleTrimMemory( 19321 ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN); 19322 } catch (RemoteException e) { 19323 } 19324 } 19325 app.pendingUiClean = false; 19326 } 19327 app.trimMemoryLevel = 0; 19328 } 19329 } 19330 19331 if (mAlwaysFinishActivities) { 19332 // Need to do this on its own message because the stack may not 19333 // be in a consistent state at this point. 19334 mStackSupervisor.scheduleDestroyAllActivities(null, "always-finish"); 19335 } 19336 19337 if (allChanged) { 19338 requestPssAllProcsLocked(now, false, mProcessStats.isMemFactorLowered()); 19339 } 19340 19341 // Update from any uid changes. 19342 for (int i=mActiveUids.size()-1; i>=0; i--) { 19343 final UidRecord uidRec = mActiveUids.valueAt(i); 19344 if (uidRec.setProcState != uidRec.curProcState) { 19345 if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS, 19346 "Changes in " + uidRec + ": proc state from " + uidRec.setProcState 19347 + " to " + uidRec.curProcState); 19348 uidRec.setProcState = uidRec.curProcState; 19349 enqueueUidChangeLocked(uidRec, false); 19350 } 19351 } 19352 19353 if (mProcessStats.shouldWriteNowLocked(now)) { 19354 mHandler.post(new Runnable() { 19355 @Override public void run() { 19356 synchronized (ActivityManagerService.this) { 19357 mProcessStats.writeStateAsyncLocked(); 19358 } 19359 } 19360 }); 19361 } 19362 19363 if (DEBUG_OOM_ADJ) { 19364 final long duration = SystemClock.uptimeMillis() - now; 19365 if (false) { 19366 Slog.d(TAG_OOM_ADJ, "Did OOM ADJ in " + duration + "ms", 19367 new RuntimeException("here").fillInStackTrace()); 19368 } else { 19369 Slog.d(TAG_OOM_ADJ, "Did OOM ADJ in " + duration + "ms"); 19370 } 19371 } 19372 } 19373 19374 final void trimApplications() { 19375 synchronized (this) { 19376 int i; 19377 19378 // First remove any unused application processes whose package 19379 // has been removed. 19380 for (i=mRemovedProcesses.size()-1; i>=0; i--) { 19381 final ProcessRecord app = mRemovedProcesses.get(i); 19382 if (app.activities.size() == 0 19383 && app.curReceiver == null && app.services.size() == 0) { 19384 Slog.i( 19385 TAG, "Exiting empty application process " 19386 + app.processName + " (" 19387 + (app.thread != null ? app.thread.asBinder() : null) 19388 + ")\n"); 19389 if (app.pid > 0 && app.pid != MY_PID) { 19390 app.kill("empty", false); 19391 } else { 19392 try { 19393 app.thread.scheduleExit(); 19394 } catch (Exception e) { 19395 // Ignore exceptions. 19396 } 19397 } 19398 cleanUpApplicationRecordLocked(app, false, true, -1); 19399 mRemovedProcesses.remove(i); 19400 19401 if (app.persistent) { 19402 addAppLocked(app.info, false, null /* ABI override */); 19403 } 19404 } 19405 } 19406 19407 // Now update the oom adj for all processes. 19408 updateOomAdjLocked(); 19409 } 19410 } 19411 19412 /** This method sends the specified signal to each of the persistent apps */ 19413 public void signalPersistentProcesses(int sig) throws RemoteException { 19414 if (sig != Process.SIGNAL_USR1) { 19415 throw new SecurityException("Only SIGNAL_USR1 is allowed"); 19416 } 19417 19418 synchronized (this) { 19419 if (checkCallingPermission(android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES) 19420 != PackageManager.PERMISSION_GRANTED) { 19421 throw new SecurityException("Requires permission " 19422 + android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES); 19423 } 19424 19425 for (int i = mLruProcesses.size() - 1 ; i >= 0 ; i--) { 19426 ProcessRecord r = mLruProcesses.get(i); 19427 if (r.thread != null && r.persistent) { 19428 Process.sendSignal(r.pid, sig); 19429 } 19430 } 19431 } 19432 } 19433 19434 private void stopProfilerLocked(ProcessRecord proc, int profileType) { 19435 if (proc == null || proc == mProfileProc) { 19436 proc = mProfileProc; 19437 profileType = mProfileType; 19438 clearProfilerLocked(); 19439 } 19440 if (proc == null) { 19441 return; 19442 } 19443 try { 19444 proc.thread.profilerControl(false, null, profileType); 19445 } catch (RemoteException e) { 19446 throw new IllegalStateException("Process disappeared"); 19447 } 19448 } 19449 19450 private void clearProfilerLocked() { 19451 if (mProfileFd != null) { 19452 try { 19453 mProfileFd.close(); 19454 } catch (IOException e) { 19455 } 19456 } 19457 mProfileApp = null; 19458 mProfileProc = null; 19459 mProfileFile = null; 19460 mProfileType = 0; 19461 mAutoStopProfiler = false; 19462 mSamplingInterval = 0; 19463 } 19464 19465 public boolean profileControl(String process, int userId, boolean start, 19466 ProfilerInfo profilerInfo, int profileType) throws RemoteException { 19467 19468 try { 19469 synchronized (this) { 19470 // note: hijacking SET_ACTIVITY_WATCHER, but should be changed to 19471 // its own permission. 19472 if (checkCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) 19473 != PackageManager.PERMISSION_GRANTED) { 19474 throw new SecurityException("Requires permission " 19475 + android.Manifest.permission.SET_ACTIVITY_WATCHER); 19476 } 19477 19478 if (start && (profilerInfo == null || profilerInfo.profileFd == null)) { 19479 throw new IllegalArgumentException("null profile info or fd"); 19480 } 19481 19482 ProcessRecord proc = null; 19483 if (process != null) { 19484 proc = findProcessLocked(process, userId, "profileControl"); 19485 } 19486 19487 if (start && (proc == null || proc.thread == null)) { 19488 throw new IllegalArgumentException("Unknown process: " + process); 19489 } 19490 19491 if (start) { 19492 stopProfilerLocked(null, 0); 19493 setProfileApp(proc.info, proc.processName, profilerInfo); 19494 mProfileProc = proc; 19495 mProfileType = profileType; 19496 ParcelFileDescriptor fd = profilerInfo.profileFd; 19497 try { 19498 fd = fd.dup(); 19499 } catch (IOException e) { 19500 fd = null; 19501 } 19502 profilerInfo.profileFd = fd; 19503 proc.thread.profilerControl(start, profilerInfo, profileType); 19504 fd = null; 19505 mProfileFd = null; 19506 } else { 19507 stopProfilerLocked(proc, profileType); 19508 if (profilerInfo != null && profilerInfo.profileFd != null) { 19509 try { 19510 profilerInfo.profileFd.close(); 19511 } catch (IOException e) { 19512 } 19513 } 19514 } 19515 19516 return true; 19517 } 19518 } catch (RemoteException e) { 19519 throw new IllegalStateException("Process disappeared"); 19520 } finally { 19521 if (profilerInfo != null && profilerInfo.profileFd != null) { 19522 try { 19523 profilerInfo.profileFd.close(); 19524 } catch (IOException e) { 19525 } 19526 } 19527 } 19528 } 19529 19530 private ProcessRecord findProcessLocked(String process, int userId, String callName) { 19531 userId = handleIncomingUser(Binder.getCallingPid(), Binder.getCallingUid(), 19532 userId, true, ALLOW_FULL_ONLY, callName, null); 19533 ProcessRecord proc = null; 19534 try { 19535 int pid = Integer.parseInt(process); 19536 synchronized (mPidsSelfLocked) { 19537 proc = mPidsSelfLocked.get(pid); 19538 } 19539 } catch (NumberFormatException e) { 19540 } 19541 19542 if (proc == null) { 19543 ArrayMap<String, SparseArray<ProcessRecord>> all 19544 = mProcessNames.getMap(); 19545 SparseArray<ProcessRecord> procs = all.get(process); 19546 if (procs != null && procs.size() > 0) { 19547 proc = procs.valueAt(0); 19548 if (userId != UserHandle.USER_ALL && proc.userId != userId) { 19549 for (int i=1; i<procs.size(); i++) { 19550 ProcessRecord thisProc = procs.valueAt(i); 19551 if (thisProc.userId == userId) { 19552 proc = thisProc; 19553 break; 19554 } 19555 } 19556 } 19557 } 19558 } 19559 19560 return proc; 19561 } 19562 19563 public boolean dumpHeap(String process, int userId, boolean managed, 19564 String path, ParcelFileDescriptor fd) throws RemoteException { 19565 19566 try { 19567 synchronized (this) { 19568 // note: hijacking SET_ACTIVITY_WATCHER, but should be changed to 19569 // its own permission (same as profileControl). 19570 if (checkCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER) 19571 != PackageManager.PERMISSION_GRANTED) { 19572 throw new SecurityException("Requires permission " 19573 + android.Manifest.permission.SET_ACTIVITY_WATCHER); 19574 } 19575 19576 if (fd == null) { 19577 throw new IllegalArgumentException("null fd"); 19578 } 19579 19580 ProcessRecord proc = findProcessLocked(process, userId, "dumpHeap"); 19581 if (proc == null || proc.thread == null) { 19582 throw new IllegalArgumentException("Unknown process: " + process); 19583 } 19584 19585 boolean isDebuggable = "1".equals(SystemProperties.get(SYSTEM_DEBUGGABLE, "0")); 19586 if (!isDebuggable) { 19587 if ((proc.info.flags&ApplicationInfo.FLAG_DEBUGGABLE) == 0) { 19588 throw new SecurityException("Process not debuggable: " + proc); 19589 } 19590 } 19591 19592 proc.thread.dumpHeap(managed, path, fd); 19593 fd = null; 19594 return true; 19595 } 19596 } catch (RemoteException e) { 19597 throw new IllegalStateException("Process disappeared"); 19598 } finally { 19599 if (fd != null) { 19600 try { 19601 fd.close(); 19602 } catch (IOException e) { 19603 } 19604 } 19605 } 19606 } 19607 19608 @Override 19609 public void setDumpHeapDebugLimit(String processName, int uid, long maxMemSize, 19610 String reportPackage) { 19611 if (processName != null) { 19612 enforceCallingPermission(android.Manifest.permission.SET_DEBUG_APP, 19613 "setDumpHeapDebugLimit()"); 19614 } else { 19615 synchronized (mPidsSelfLocked) { 19616 ProcessRecord proc = mPidsSelfLocked.get(Binder.getCallingPid()); 19617 if (proc == null) { 19618 throw new SecurityException("No process found for calling pid " 19619 + Binder.getCallingPid()); 19620 } 19621 if (!Build.IS_DEBUGGABLE 19622 && (proc.info.flags&ApplicationInfo.FLAG_DEBUGGABLE) == 0) { 19623 throw new SecurityException("Not running a debuggable build"); 19624 } 19625 processName = proc.processName; 19626 uid = proc.uid; 19627 if (reportPackage != null && !proc.pkgList.containsKey(reportPackage)) { 19628 throw new SecurityException("Package " + reportPackage + " is not running in " 19629 + proc); 19630 } 19631 } 19632 } 19633 synchronized (this) { 19634 if (maxMemSize > 0) { 19635 mMemWatchProcesses.put(processName, uid, new Pair(maxMemSize, reportPackage)); 19636 } else { 19637 if (uid != 0) { 19638 mMemWatchProcesses.remove(processName, uid); 19639 } else { 19640 mMemWatchProcesses.getMap().remove(processName); 19641 } 19642 } 19643 } 19644 } 19645 19646 @Override 19647 public void dumpHeapFinished(String path) { 19648 synchronized (this) { 19649 if (Binder.getCallingPid() != mMemWatchDumpPid) { 19650 Slog.w(TAG, "dumpHeapFinished: Calling pid " + Binder.getCallingPid() 19651 + " does not match last pid " + mMemWatchDumpPid); 19652 return; 19653 } 19654 if (mMemWatchDumpFile == null || !mMemWatchDumpFile.equals(path)) { 19655 Slog.w(TAG, "dumpHeapFinished: Calling path " + path 19656 + " does not match last path " + mMemWatchDumpFile); 19657 return; 19658 } 19659 if (DEBUG_PSS) Slog.d(TAG_PSS, "Dump heap finished for " + path); 19660 mHandler.sendEmptyMessage(POST_DUMP_HEAP_NOTIFICATION_MSG); 19661 } 19662 } 19663 19664 /** In this method we try to acquire our lock to make sure that we have not deadlocked */ 19665 public void monitor() { 19666 synchronized (this) { } 19667 } 19668 19669 void onCoreSettingsChange(Bundle settings) { 19670 for (int i = mLruProcesses.size() - 1; i >= 0; i--) { 19671 ProcessRecord processRecord = mLruProcesses.get(i); 19672 try { 19673 if (processRecord.thread != null) { 19674 processRecord.thread.setCoreSettings(settings); 19675 } 19676 } catch (RemoteException re) { 19677 /* ignore */ 19678 } 19679 } 19680 } 19681 19682 // Multi-user methods 19683 19684 /** 19685 * Start user, if its not already running, but don't bring it to foreground. 19686 */ 19687 @Override 19688 public boolean startUserInBackground(final int userId) { 19689 return startUser(userId, /* foreground */ false); 19690 } 19691 19692 /** 19693 * Start user, if its not already running, and bring it to foreground. 19694 */ 19695 boolean startUserInForeground(final int userId, Dialog dlg) { 19696 boolean result = startUser(userId, /* foreground */ true); 19697 dlg.dismiss(); 19698 return result; 19699 } 19700 19701 /** 19702 * Refreshes the list of users related to the current user when either a 19703 * user switch happens or when a new related user is started in the 19704 * background. 19705 */ 19706 private void updateCurrentProfileIdsLocked() { 19707 final List<UserInfo> profiles = getUserManagerLocked().getProfiles( 19708 mCurrentUserId, false /* enabledOnly */); 19709 int[] currentProfileIds = new int[profiles.size()]; // profiles will not be null 19710 for (int i = 0; i < currentProfileIds.length; i++) { 19711 currentProfileIds[i] = profiles.get(i).id; 19712 } 19713 mCurrentProfileIds = currentProfileIds; 19714 19715 synchronized (mUserProfileGroupIdsSelfLocked) { 19716 mUserProfileGroupIdsSelfLocked.clear(); 19717 final List<UserInfo> users = getUserManagerLocked().getUsers(false); 19718 for (int i = 0; i < users.size(); i++) { 19719 UserInfo user = users.get(i); 19720 if (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID) { 19721 mUserProfileGroupIdsSelfLocked.put(user.id, user.profileGroupId); 19722 } 19723 } 19724 } 19725 } 19726 19727 private Set<Integer> getProfileIdsLocked(int userId) { 19728 Set<Integer> userIds = new HashSet<Integer>(); 19729 final List<UserInfo> profiles = getUserManagerLocked().getProfiles( 19730 userId, false /* enabledOnly */); 19731 for (UserInfo user : profiles) { 19732 userIds.add(Integer.valueOf(user.id)); 19733 } 19734 return userIds; 19735 } 19736 19737 @Override 19738 public boolean switchUser(final int userId) { 19739 enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId); 19740 String userName; 19741 synchronized (this) { 19742 UserInfo userInfo = getUserManagerLocked().getUserInfo(userId); 19743 if (userInfo == null) { 19744 Slog.w(TAG, "No user info for user #" + userId); 19745 return false; 19746 } 19747 if (userInfo.isManagedProfile()) { 19748 Slog.w(TAG, "Cannot switch to User #" + userId + ": not a full user"); 19749 return false; 19750 } 19751 userName = userInfo.name; 19752 mTargetUserId = userId; 19753 } 19754 mUiHandler.removeMessages(START_USER_SWITCH_MSG); 19755 mUiHandler.sendMessage(mUiHandler.obtainMessage(START_USER_SWITCH_MSG, userId, 0, userName)); 19756 return true; 19757 } 19758 19759 private void showUserSwitchDialog(int userId, String userName) { 19760 // The dialog will show and then initiate the user switch by calling startUserInForeground 19761 Dialog d = new UserSwitchingDialog(this, mContext, userId, userName, 19762 true /* above system */); 19763 d.show(); 19764 } 19765 19766 private boolean startUser(final int userId, final boolean foreground) { 19767 if (checkCallingPermission(INTERACT_ACROSS_USERS_FULL) 19768 != PackageManager.PERMISSION_GRANTED) { 19769 String msg = "Permission Denial: switchUser() from pid=" 19770 + Binder.getCallingPid() 19771 + ", uid=" + Binder.getCallingUid() 19772 + " requires " + INTERACT_ACROSS_USERS_FULL; 19773 Slog.w(TAG, msg); 19774 throw new SecurityException(msg); 19775 } 19776 19777 if (DEBUG_MU) Slog.i(TAG_MU, "starting userid:" + userId + " fore:" + foreground); 19778 19779 final long ident = Binder.clearCallingIdentity(); 19780 try { 19781 synchronized (this) { 19782 final int oldUserId = mCurrentUserId; 19783 if (oldUserId == userId) { 19784 return true; 19785 } 19786 19787 mStackSupervisor.setLockTaskModeLocked(null, ActivityManager.LOCK_TASK_MODE_NONE, 19788 "startUser", false); 19789 19790 final UserInfo userInfo = getUserManagerLocked().getUserInfo(userId); 19791 if (userInfo == null) { 19792 Slog.w(TAG, "No user info for user #" + userId); 19793 return false; 19794 } 19795 if (foreground && userInfo.isManagedProfile()) { 19796 Slog.w(TAG, "Cannot switch to User #" + userId + ": not a full user"); 19797 return false; 19798 } 19799 19800 if (foreground) { 19801 mWindowManager.startFreezingScreen(R.anim.screen_user_exit, 19802 R.anim.screen_user_enter); 19803 } 19804 19805 boolean needStart = false; 19806 19807 // If the user we are switching to is not currently started, then 19808 // we need to start it now. 19809 if (mStartedUsers.get(userId) == null) { 19810 mStartedUsers.put(userId, new UserState(new UserHandle(userId), false)); 19811 updateStartedUserArrayLocked(); 19812 needStart = true; 19813 } 19814 19815 final Integer userIdInt = Integer.valueOf(userId); 19816 mUserLru.remove(userIdInt); 19817 mUserLru.add(userIdInt); 19818 19819 if (foreground) { 19820 mCurrentUserId = userId; 19821 mTargetUserId = UserHandle.USER_NULL; // reset, mCurrentUserId has caught up 19822 updateCurrentProfileIdsLocked(); 19823 mWindowManager.setCurrentUser(userId, mCurrentProfileIds); 19824 // Once the internal notion of the active user has switched, we lock the device 19825 // with the option to show the user switcher on the keyguard. 19826 mWindowManager.lockNow(null); 19827 } else { 19828 final Integer currentUserIdInt = Integer.valueOf(mCurrentUserId); 19829 updateCurrentProfileIdsLocked(); 19830 mWindowManager.setCurrentProfileIds(mCurrentProfileIds); 19831 mUserLru.remove(currentUserIdInt); 19832 mUserLru.add(currentUserIdInt); 19833 } 19834 19835 final UserState uss = mStartedUsers.get(userId); 19836 19837 // Make sure user is in the started state. If it is currently 19838 // stopping, we need to knock that off. 19839 if (uss.mState == UserState.STATE_STOPPING) { 19840 // If we are stopping, we haven't sent ACTION_SHUTDOWN, 19841 // so we can just fairly silently bring the user back from 19842 // the almost-dead. 19843 uss.mState = UserState.STATE_RUNNING; 19844 updateStartedUserArrayLocked(); 19845 needStart = true; 19846 } else if (uss.mState == UserState.STATE_SHUTDOWN) { 19847 // This means ACTION_SHUTDOWN has been sent, so we will 19848 // need to treat this as a new boot of the user. 19849 uss.mState = UserState.STATE_BOOTING; 19850 updateStartedUserArrayLocked(); 19851 needStart = true; 19852 } 19853 19854 if (uss.mState == UserState.STATE_BOOTING) { 19855 // Booting up a new user, need to tell system services about it. 19856 // Note that this is on the same handler as scheduling of broadcasts, 19857 // which is important because it needs to go first. 19858 mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_START_MSG, userId, 0)); 19859 } 19860 19861 if (foreground) { 19862 mHandler.sendMessage(mHandler.obtainMessage(SYSTEM_USER_CURRENT_MSG, userId, 19863 oldUserId)); 19864 mHandler.removeMessages(REPORT_USER_SWITCH_MSG); 19865 mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG); 19866 mHandler.sendMessage(mHandler.obtainMessage(REPORT_USER_SWITCH_MSG, 19867 oldUserId, userId, uss)); 19868 mHandler.sendMessageDelayed(mHandler.obtainMessage(USER_SWITCH_TIMEOUT_MSG, 19869 oldUserId, userId, uss), USER_SWITCH_TIMEOUT); 19870 } 19871 19872 if (needStart) { 19873 // Send USER_STARTED broadcast 19874 Intent intent = new Intent(Intent.ACTION_USER_STARTED); 19875 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 19876 | Intent.FLAG_RECEIVER_FOREGROUND); 19877 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 19878 broadcastIntentLocked(null, null, intent, 19879 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 19880 null, false, false, MY_PID, Process.SYSTEM_UID, userId); 19881 } 19882 19883 if ((userInfo.flags&UserInfo.FLAG_INITIALIZED) == 0) { 19884 if (userId != UserHandle.USER_OWNER) { 19885 Intent intent = new Intent(Intent.ACTION_USER_INITIALIZE); 19886 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); 19887 broadcastIntentLocked(null, null, intent, null, 19888 new IIntentReceiver.Stub() { 19889 public void performReceive(Intent intent, int resultCode, 19890 String data, Bundle extras, boolean ordered, 19891 boolean sticky, int sendingUser) { 19892 onUserInitialized(uss, foreground, oldUserId, userId); 19893 } 19894 }, 0, null, null, null, AppOpsManager.OP_NONE, 19895 null, true, false, MY_PID, Process.SYSTEM_UID, userId); 19896 uss.initializing = true; 19897 } else { 19898 getUserManagerLocked().makeInitialized(userInfo.id); 19899 } 19900 } 19901 19902 if (foreground) { 19903 if (!uss.initializing) { 19904 moveUserToForeground(uss, oldUserId, userId); 19905 } 19906 } else { 19907 mStackSupervisor.startBackgroundUserLocked(userId, uss); 19908 } 19909 19910 if (needStart) { 19911 Intent intent = new Intent(Intent.ACTION_USER_STARTING); 19912 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 19913 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 19914 broadcastIntentLocked(null, null, intent, 19915 null, new IIntentReceiver.Stub() { 19916 @Override 19917 public void performReceive(Intent intent, int resultCode, 19918 String data, Bundle extras, boolean ordered, boolean sticky, 19919 int sendingUser) throws RemoteException { 19920 } 19921 }, 0, null, null, 19922 new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, 19923 null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 19924 } 19925 } 19926 } finally { 19927 Binder.restoreCallingIdentity(ident); 19928 } 19929 19930 return true; 19931 } 19932 19933 void dispatchForegroundProfileChanged(int userId) { 19934 final int N = mUserSwitchObservers.beginBroadcast(); 19935 for (int i = 0; i < N; i++) { 19936 try { 19937 mUserSwitchObservers.getBroadcastItem(i).onForegroundProfileSwitch(userId); 19938 } catch (RemoteException e) { 19939 // Ignore 19940 } 19941 } 19942 mUserSwitchObservers.finishBroadcast(); 19943 } 19944 19945 void sendUserSwitchBroadcastsLocked(int oldUserId, int newUserId) { 19946 long ident = Binder.clearCallingIdentity(); 19947 try { 19948 Intent intent; 19949 if (oldUserId >= 0) { 19950 // Send USER_BACKGROUND broadcast to all profiles of the outgoing user 19951 List<UserInfo> profiles = mUserManager.getProfiles(oldUserId, false); 19952 int count = profiles.size(); 19953 for (int i = 0; i < count; i++) { 19954 int profileUserId = profiles.get(i).id; 19955 intent = new Intent(Intent.ACTION_USER_BACKGROUND); 19956 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 19957 | Intent.FLAG_RECEIVER_FOREGROUND); 19958 intent.putExtra(Intent.EXTRA_USER_HANDLE, profileUserId); 19959 broadcastIntentLocked(null, null, intent, 19960 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 19961 null, false, false, MY_PID, Process.SYSTEM_UID, profileUserId); 19962 } 19963 } 19964 if (newUserId >= 0) { 19965 // Send USER_FOREGROUND broadcast to all profiles of the incoming user 19966 List<UserInfo> profiles = mUserManager.getProfiles(newUserId, false); 19967 int count = profiles.size(); 19968 for (int i = 0; i < count; i++) { 19969 int profileUserId = profiles.get(i).id; 19970 intent = new Intent(Intent.ACTION_USER_FOREGROUND); 19971 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 19972 | Intent.FLAG_RECEIVER_FOREGROUND); 19973 intent.putExtra(Intent.EXTRA_USER_HANDLE, profileUserId); 19974 broadcastIntentLocked(null, null, intent, 19975 null, null, 0, null, null, null, AppOpsManager.OP_NONE, 19976 null, false, false, MY_PID, Process.SYSTEM_UID, profileUserId); 19977 } 19978 intent = new Intent(Intent.ACTION_USER_SWITCHED); 19979 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY 19980 | Intent.FLAG_RECEIVER_FOREGROUND); 19981 intent.putExtra(Intent.EXTRA_USER_HANDLE, newUserId); 19982 broadcastIntentLocked(null, null, intent, 19983 null, null, 0, null, null, 19984 new String[] {android.Manifest.permission.MANAGE_USERS}, 19985 AppOpsManager.OP_NONE, null, false, false, MY_PID, Process.SYSTEM_UID, 19986 UserHandle.USER_ALL); 19987 } 19988 } finally { 19989 Binder.restoreCallingIdentity(ident); 19990 } 19991 } 19992 19993 void dispatchUserSwitch(final UserState uss, final int oldUserId, 19994 final int newUserId) { 19995 final int N = mUserSwitchObservers.beginBroadcast(); 19996 if (N > 0) { 19997 final IRemoteCallback callback = new IRemoteCallback.Stub() { 19998 int mCount = 0; 19999 @Override 20000 public void sendResult(Bundle data) throws RemoteException { 20001 synchronized (ActivityManagerService.this) { 20002 if (mCurUserSwitchCallback == this) { 20003 mCount++; 20004 if (mCount == N) { 20005 sendContinueUserSwitchLocked(uss, oldUserId, newUserId); 20006 } 20007 } 20008 } 20009 } 20010 }; 20011 synchronized (this) { 20012 uss.switching = true; 20013 mCurUserSwitchCallback = callback; 20014 } 20015 for (int i=0; i<N; i++) { 20016 try { 20017 mUserSwitchObservers.getBroadcastItem(i).onUserSwitching( 20018 newUserId, callback); 20019 } catch (RemoteException e) { 20020 } 20021 } 20022 } else { 20023 synchronized (this) { 20024 sendContinueUserSwitchLocked(uss, oldUserId, newUserId); 20025 } 20026 } 20027 mUserSwitchObservers.finishBroadcast(); 20028 } 20029 20030 void timeoutUserSwitch(UserState uss, int oldUserId, int newUserId) { 20031 synchronized (this) { 20032 Slog.w(TAG, "User switch timeout: from " + oldUserId + " to " + newUserId); 20033 sendContinueUserSwitchLocked(uss, oldUserId, newUserId); 20034 } 20035 } 20036 20037 void sendContinueUserSwitchLocked(UserState uss, int oldUserId, int newUserId) { 20038 mCurUserSwitchCallback = null; 20039 mHandler.removeMessages(USER_SWITCH_TIMEOUT_MSG); 20040 mHandler.sendMessage(mHandler.obtainMessage(CONTINUE_USER_SWITCH_MSG, 20041 oldUserId, newUserId, uss)); 20042 } 20043 20044 void onUserInitialized(UserState uss, boolean foreground, int oldUserId, int newUserId) { 20045 synchronized (this) { 20046 if (foreground) { 20047 moveUserToForeground(uss, oldUserId, newUserId); 20048 } 20049 } 20050 20051 completeSwitchAndInitialize(uss, newUserId, true, false); 20052 } 20053 20054 void moveUserToForeground(UserState uss, int oldUserId, int newUserId) { 20055 boolean homeInFront = mStackSupervisor.switchUserLocked(newUserId, uss); 20056 if (homeInFront) { 20057 startHomeActivityLocked(newUserId, "moveUserToFroreground"); 20058 } else { 20059 mStackSupervisor.resumeTopActivitiesLocked(); 20060 } 20061 EventLogTags.writeAmSwitchUser(newUserId); 20062 getUserManagerLocked().onUserForeground(newUserId); 20063 sendUserSwitchBroadcastsLocked(oldUserId, newUserId); 20064 } 20065 20066 void continueUserSwitch(UserState uss, int oldUserId, int newUserId) { 20067 completeSwitchAndInitialize(uss, newUserId, false, true); 20068 } 20069 20070 void completeSwitchAndInitialize(UserState uss, int newUserId, 20071 boolean clearInitializing, boolean clearSwitching) { 20072 boolean unfrozen = false; 20073 synchronized (this) { 20074 if (clearInitializing) { 20075 uss.initializing = false; 20076 getUserManagerLocked().makeInitialized(uss.mHandle.getIdentifier()); 20077 } 20078 if (clearSwitching) { 20079 uss.switching = false; 20080 } 20081 if (!uss.switching && !uss.initializing) { 20082 mWindowManager.stopFreezingScreen(); 20083 unfrozen = true; 20084 } 20085 } 20086 if (unfrozen) { 20087 mHandler.removeMessages(REPORT_USER_SWITCH_COMPLETE_MSG); 20088 mHandler.sendMessage(mHandler.obtainMessage(REPORT_USER_SWITCH_COMPLETE_MSG, 20089 newUserId, 0)); 20090 } 20091 stopGuestUserIfBackground(); 20092 } 20093 20094 /** Called on handler thread */ 20095 void dispatchUserSwitchComplete(int userId) { 20096 final int observerCount = mUserSwitchObservers.beginBroadcast(); 20097 for (int i = 0; i < observerCount; i++) { 20098 try { 20099 mUserSwitchObservers.getBroadcastItem(i).onUserSwitchComplete(userId); 20100 } catch (RemoteException e) { 20101 } 20102 } 20103 mUserSwitchObservers.finishBroadcast(); 20104 } 20105 20106 /** 20107 * Stops the guest user if it has gone to the background. 20108 */ 20109 private void stopGuestUserIfBackground() { 20110 synchronized (this) { 20111 final int num = mUserLru.size(); 20112 for (int i = 0; i < num; i++) { 20113 Integer oldUserId = mUserLru.get(i); 20114 UserState oldUss = mStartedUsers.get(oldUserId); 20115 if (oldUserId == UserHandle.USER_OWNER || oldUserId == mCurrentUserId 20116 || oldUss.mState == UserState.STATE_STOPPING 20117 || oldUss.mState == UserState.STATE_SHUTDOWN) { 20118 continue; 20119 } 20120 UserInfo userInfo = mUserManager.getUserInfo(oldUserId); 20121 if (userInfo.isGuest()) { 20122 // This is a user to be stopped. 20123 stopUserLocked(oldUserId, null); 20124 break; 20125 } 20126 } 20127 } 20128 } 20129 20130 void scheduleStartProfilesLocked() { 20131 if (!mHandler.hasMessages(START_PROFILES_MSG)) { 20132 mHandler.sendMessageDelayed(mHandler.obtainMessage(START_PROFILES_MSG), 20133 DateUtils.SECOND_IN_MILLIS); 20134 } 20135 } 20136 20137 void startProfilesLocked() { 20138 if (DEBUG_MU) Slog.i(TAG_MU, "startProfilesLocked"); 20139 List<UserInfo> profiles = getUserManagerLocked().getProfiles( 20140 mCurrentUserId, false /* enabledOnly */); 20141 List<UserInfo> toStart = new ArrayList<UserInfo>(profiles.size()); 20142 for (UserInfo user : profiles) { 20143 if ((user.flags & UserInfo.FLAG_INITIALIZED) == UserInfo.FLAG_INITIALIZED 20144 && user.id != mCurrentUserId) { 20145 toStart.add(user); 20146 } 20147 } 20148 final int n = toStart.size(); 20149 int i = 0; 20150 for (; i < n && i < (MAX_RUNNING_USERS - 1); ++i) { 20151 startUserInBackground(toStart.get(i).id); 20152 } 20153 if (i < n) { 20154 Slog.w(TAG_MU, "More profiles than MAX_RUNNING_USERS"); 20155 } 20156 } 20157 20158 void finishUserBoot(UserState uss) { 20159 synchronized (this) { 20160 if (uss.mState == UserState.STATE_BOOTING 20161 && mStartedUsers.get(uss.mHandle.getIdentifier()) == uss) { 20162 uss.mState = UserState.STATE_RUNNING; 20163 final int userId = uss.mHandle.getIdentifier(); 20164 Intent intent = new Intent(Intent.ACTION_BOOT_COMPLETED, null); 20165 intent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 20166 intent.addFlags(Intent.FLAG_RECEIVER_NO_ABORT); 20167 broadcastIntentLocked(null, null, intent, 20168 null, null, 0, null, null, 20169 new String[] {android.Manifest.permission.RECEIVE_BOOT_COMPLETED}, 20170 AppOpsManager.OP_NONE, null, true, false, MY_PID, Process.SYSTEM_UID, 20171 userId); 20172 } 20173 } 20174 } 20175 20176 void finishUserSwitch(UserState uss) { 20177 synchronized (this) { 20178 finishUserBoot(uss); 20179 20180 startProfilesLocked(); 20181 20182 int num = mUserLru.size(); 20183 int i = 0; 20184 while (num > MAX_RUNNING_USERS && i < mUserLru.size()) { 20185 Integer oldUserId = mUserLru.get(i); 20186 UserState oldUss = mStartedUsers.get(oldUserId); 20187 if (oldUss == null) { 20188 // Shouldn't happen, but be sane if it does. 20189 mUserLru.remove(i); 20190 num--; 20191 continue; 20192 } 20193 if (oldUss.mState == UserState.STATE_STOPPING 20194 || oldUss.mState == UserState.STATE_SHUTDOWN) { 20195 // This user is already stopping, doesn't count. 20196 num--; 20197 i++; 20198 continue; 20199 } 20200 if (oldUserId == UserHandle.USER_OWNER || oldUserId == mCurrentUserId) { 20201 // Owner and current can't be stopped, but count as running. 20202 i++; 20203 continue; 20204 } 20205 // This is a user to be stopped. 20206 stopUserLocked(oldUserId, null); 20207 num--; 20208 i++; 20209 } 20210 } 20211 } 20212 20213 @Override 20214 public int stopUser(final int userId, final IStopUserCallback callback) { 20215 if (checkCallingPermission(INTERACT_ACROSS_USERS_FULL) 20216 != PackageManager.PERMISSION_GRANTED) { 20217 String msg = "Permission Denial: switchUser() from pid=" 20218 + Binder.getCallingPid() 20219 + ", uid=" + Binder.getCallingUid() 20220 + " requires " + INTERACT_ACROSS_USERS_FULL; 20221 Slog.w(TAG, msg); 20222 throw new SecurityException(msg); 20223 } 20224 if (userId < 0 || userId == UserHandle.USER_OWNER) { 20225 throw new IllegalArgumentException("Can't stop primary user " + userId); 20226 } 20227 enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, userId); 20228 synchronized (this) { 20229 return stopUserLocked(userId, callback); 20230 } 20231 } 20232 20233 private int stopUserLocked(final int userId, final IStopUserCallback callback) { 20234 if (DEBUG_MU) Slog.i(TAG_MU, "stopUserLocked userId=" + userId); 20235 if (mCurrentUserId == userId && mTargetUserId == UserHandle.USER_NULL) { 20236 return ActivityManager.USER_OP_IS_CURRENT; 20237 } 20238 20239 final UserState uss = mStartedUsers.get(userId); 20240 if (uss == null) { 20241 // User is not started, nothing to do... but we do need to 20242 // callback if requested. 20243 if (callback != null) { 20244 mHandler.post(new Runnable() { 20245 @Override 20246 public void run() { 20247 try { 20248 callback.userStopped(userId); 20249 } catch (RemoteException e) { 20250 } 20251 } 20252 }); 20253 } 20254 return ActivityManager.USER_OP_SUCCESS; 20255 } 20256 20257 if (callback != null) { 20258 uss.mStopCallbacks.add(callback); 20259 } 20260 20261 if (uss.mState != UserState.STATE_STOPPING 20262 && uss.mState != UserState.STATE_SHUTDOWN) { 20263 uss.mState = UserState.STATE_STOPPING; 20264 updateStartedUserArrayLocked(); 20265 20266 long ident = Binder.clearCallingIdentity(); 20267 try { 20268 // We are going to broadcast ACTION_USER_STOPPING and then 20269 // once that is done send a final ACTION_SHUTDOWN and then 20270 // stop the user. 20271 final Intent stoppingIntent = new Intent(Intent.ACTION_USER_STOPPING); 20272 stoppingIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 20273 stoppingIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 20274 stoppingIntent.putExtra(Intent.EXTRA_SHUTDOWN_USERSPACE_ONLY, true); 20275 final Intent shutdownIntent = new Intent(Intent.ACTION_SHUTDOWN); 20276 // This is the result receiver for the final shutdown broadcast. 20277 final IIntentReceiver shutdownReceiver = new IIntentReceiver.Stub() { 20278 @Override 20279 public void performReceive(Intent intent, int resultCode, String data, 20280 Bundle extras, boolean ordered, boolean sticky, int sendingUser) { 20281 finishUserStop(uss); 20282 } 20283 }; 20284 // This is the result receiver for the initial stopping broadcast. 20285 final IIntentReceiver stoppingReceiver = new IIntentReceiver.Stub() { 20286 @Override 20287 public void performReceive(Intent intent, int resultCode, String data, 20288 Bundle extras, boolean ordered, boolean sticky, int sendingUser) { 20289 // On to the next. 20290 synchronized (ActivityManagerService.this) { 20291 if (uss.mState != UserState.STATE_STOPPING) { 20292 // Whoops, we are being started back up. Abort, abort! 20293 return; 20294 } 20295 uss.mState = UserState.STATE_SHUTDOWN; 20296 } 20297 mBatteryStatsService.noteEvent( 20298 BatteryStats.HistoryItem.EVENT_USER_RUNNING_FINISH, 20299 Integer.toString(userId), userId); 20300 mSystemServiceManager.stopUser(userId); 20301 broadcastIntentLocked(null, null, shutdownIntent, 20302 null, shutdownReceiver, 0, null, null, null, AppOpsManager.OP_NONE, 20303 null, true, false, MY_PID, Process.SYSTEM_UID, userId); 20304 } 20305 }; 20306 // Kick things off. 20307 broadcastIntentLocked(null, null, stoppingIntent, 20308 null, stoppingReceiver, 0, null, null, 20309 new String[] {INTERACT_ACROSS_USERS}, AppOpsManager.OP_NONE, 20310 null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL); 20311 } finally { 20312 Binder.restoreCallingIdentity(ident); 20313 } 20314 } 20315 20316 return ActivityManager.USER_OP_SUCCESS; 20317 } 20318 20319 void finishUserStop(UserState uss) { 20320 final int userId = uss.mHandle.getIdentifier(); 20321 boolean stopped; 20322 ArrayList<IStopUserCallback> callbacks; 20323 synchronized (this) { 20324 callbacks = new ArrayList<IStopUserCallback>(uss.mStopCallbacks); 20325 if (mStartedUsers.get(userId) != uss) { 20326 stopped = false; 20327 } else if (uss.mState != UserState.STATE_SHUTDOWN) { 20328 stopped = false; 20329 } else { 20330 stopped = true; 20331 // User can no longer run. 20332 mStartedUsers.remove(userId); 20333 mUserLru.remove(Integer.valueOf(userId)); 20334 updateStartedUserArrayLocked(); 20335 20336 // Clean up all state and processes associated with the user. 20337 // Kill all the processes for the user. 20338 forceStopUserLocked(userId, "finish user"); 20339 } 20340 20341 // Explicitly remove the old information in mRecentTasks. 20342 mRecentTasks.removeTasksForUserLocked(userId); 20343 } 20344 20345 for (int i=0; i<callbacks.size(); i++) { 20346 try { 20347 if (stopped) callbacks.get(i).userStopped(userId); 20348 else callbacks.get(i).userStopAborted(userId); 20349 } catch (RemoteException e) { 20350 } 20351 } 20352 20353 if (stopped) { 20354 mSystemServiceManager.cleanupUser(userId); 20355 synchronized (this) { 20356 mStackSupervisor.removeUserLocked(userId); 20357 } 20358 } 20359 } 20360 20361 @Override 20362 public UserInfo getCurrentUser() { 20363 if ((checkCallingPermission(INTERACT_ACROSS_USERS) 20364 != PackageManager.PERMISSION_GRANTED) && ( 20365 checkCallingPermission(INTERACT_ACROSS_USERS_FULL) 20366 != PackageManager.PERMISSION_GRANTED)) { 20367 String msg = "Permission Denial: getCurrentUser() from pid=" 20368 + Binder.getCallingPid() 20369 + ", uid=" + Binder.getCallingUid() 20370 + " requires " + INTERACT_ACROSS_USERS; 20371 Slog.w(TAG, msg); 20372 throw new SecurityException(msg); 20373 } 20374 synchronized (this) { 20375 int userId = mTargetUserId != UserHandle.USER_NULL ? mTargetUserId : mCurrentUserId; 20376 return getUserManagerLocked().getUserInfo(userId); 20377 } 20378 } 20379 20380 int getCurrentUserIdLocked() { 20381 return mTargetUserId != UserHandle.USER_NULL ? mTargetUserId : mCurrentUserId; 20382 } 20383 20384 @Override 20385 public boolean isUserRunning(int userId, boolean orStopped) { 20386 if (checkCallingPermission(INTERACT_ACROSS_USERS) 20387 != PackageManager.PERMISSION_GRANTED) { 20388 String msg = "Permission Denial: isUserRunning() from pid=" 20389 + Binder.getCallingPid() 20390 + ", uid=" + Binder.getCallingUid() 20391 + " requires " + INTERACT_ACROSS_USERS; 20392 Slog.w(TAG, msg); 20393 throw new SecurityException(msg); 20394 } 20395 synchronized (this) { 20396 return isUserRunningLocked(userId, orStopped); 20397 } 20398 } 20399 20400 boolean isUserRunningLocked(int userId, boolean orStopped) { 20401 UserState state = mStartedUsers.get(userId); 20402 if (state == null) { 20403 return false; 20404 } 20405 if (orStopped) { 20406 return true; 20407 } 20408 return state.mState != UserState.STATE_STOPPING 20409 && state.mState != UserState.STATE_SHUTDOWN; 20410 } 20411 20412 @Override 20413 public int[] getRunningUserIds() { 20414 if (checkCallingPermission(INTERACT_ACROSS_USERS) 20415 != PackageManager.PERMISSION_GRANTED) { 20416 String msg = "Permission Denial: isUserRunning() from pid=" 20417 + Binder.getCallingPid() 20418 + ", uid=" + Binder.getCallingUid() 20419 + " requires " + INTERACT_ACROSS_USERS; 20420 Slog.w(TAG, msg); 20421 throw new SecurityException(msg); 20422 } 20423 synchronized (this) { 20424 return mStartedUserArray; 20425 } 20426 } 20427 20428 private void updateStartedUserArrayLocked() { 20429 int num = 0; 20430 for (int i=0; i<mStartedUsers.size(); i++) { 20431 UserState uss = mStartedUsers.valueAt(i); 20432 // This list does not include stopping users. 20433 if (uss.mState != UserState.STATE_STOPPING 20434 && uss.mState != UserState.STATE_SHUTDOWN) { 20435 num++; 20436 } 20437 } 20438 mStartedUserArray = new int[num]; 20439 num = 0; 20440 for (int i=0; i<mStartedUsers.size(); i++) { 20441 UserState uss = mStartedUsers.valueAt(i); 20442 if (uss.mState != UserState.STATE_STOPPING 20443 && uss.mState != UserState.STATE_SHUTDOWN) { 20444 mStartedUserArray[num] = mStartedUsers.keyAt(i); 20445 num++; 20446 } 20447 } 20448 } 20449 20450 @Override 20451 public void registerUserSwitchObserver(IUserSwitchObserver observer) { 20452 if (checkCallingPermission(INTERACT_ACROSS_USERS_FULL) 20453 != PackageManager.PERMISSION_GRANTED) { 20454 String msg = "Permission Denial: registerUserSwitchObserver() from pid=" 20455 + Binder.getCallingPid() 20456 + ", uid=" + Binder.getCallingUid() 20457 + " requires " + INTERACT_ACROSS_USERS_FULL; 20458 Slog.w(TAG, msg); 20459 throw new SecurityException(msg); 20460 } 20461 20462 mUserSwitchObservers.register(observer); 20463 } 20464 20465 @Override 20466 public void unregisterUserSwitchObserver(IUserSwitchObserver observer) { 20467 mUserSwitchObservers.unregister(observer); 20468 } 20469 20470 int[] getUsersLocked() { 20471 UserManagerService ums = getUserManagerLocked(); 20472 return ums != null ? ums.getUserIds() : new int[] { 0 }; 20473 } 20474 20475 UserManagerService getUserManagerLocked() { 20476 if (mUserManager == null) { 20477 IBinder b = ServiceManager.getService(Context.USER_SERVICE); 20478 mUserManager = (UserManagerService)IUserManager.Stub.asInterface(b); 20479 } 20480 return mUserManager; 20481 } 20482 20483 private int applyUserId(int uid, int userId) { 20484 return UserHandle.getUid(userId, uid); 20485 } 20486 20487 ApplicationInfo getAppInfoForUser(ApplicationInfo info, int userId) { 20488 if (info == null) return null; 20489 ApplicationInfo newInfo = new ApplicationInfo(info); 20490 newInfo.uid = applyUserId(info.uid, userId); 20491 newInfo.dataDir = Environment 20492 .getDataUserPackageDirectory(info.volumeUuid, userId, info.packageName) 20493 .getAbsolutePath(); 20494 return newInfo; 20495 } 20496 20497 ActivityInfo getActivityInfoForUser(ActivityInfo aInfo, int userId) { 20498 if (aInfo == null 20499 || (userId < 1 && aInfo.applicationInfo.uid < UserHandle.PER_USER_RANGE)) { 20500 return aInfo; 20501 } 20502 20503 ActivityInfo info = new ActivityInfo(aInfo); 20504 info.applicationInfo = getAppInfoForUser(info.applicationInfo, userId); 20505 return info; 20506 } 20507 20508 private final class LocalService extends ActivityManagerInternal { 20509 @Override 20510 public void onWakefulnessChanged(int wakefulness) { 20511 ActivityManagerService.this.onWakefulnessChanged(wakefulness); 20512 } 20513 20514 @Override 20515 public int startIsolatedProcess(String entryPoint, String[] entryPointArgs, 20516 String processName, String abiOverride, int uid, Runnable crashHandler) { 20517 return ActivityManagerService.this.startIsolatedProcess(entryPoint, entryPointArgs, 20518 processName, abiOverride, uid, crashHandler); 20519 } 20520 20521 @Override 20522 public SleepToken acquireSleepToken(String tag) { 20523 Preconditions.checkNotNull(tag); 20524 20525 synchronized (ActivityManagerService.this) { 20526 SleepTokenImpl token = new SleepTokenImpl(tag); 20527 mSleepTokens.add(token); 20528 updateSleepIfNeededLocked(); 20529 return token; 20530 } 20531 } 20532 20533 @Override 20534 public ComponentName getHomeActivityForUser(int userId) { 20535 synchronized (ActivityManagerService.this) { 20536 ActivityRecord homeActivity = mStackSupervisor.getHomeActivityForUser(userId); 20537 return homeActivity == null ? null : homeActivity.realActivity; 20538 } 20539 } 20540 } 20541 20542 private final class SleepTokenImpl extends SleepToken { 20543 private final String mTag; 20544 private final long mAcquireTime; 20545 20546 public SleepTokenImpl(String tag) { 20547 mTag = tag; 20548 mAcquireTime = SystemClock.uptimeMillis(); 20549 } 20550 20551 @Override 20552 public void release() { 20553 synchronized (ActivityManagerService.this) { 20554 if (mSleepTokens.remove(this)) { 20555 updateSleepIfNeededLocked(); 20556 } 20557 } 20558 } 20559 20560 @Override 20561 public String toString() { 20562 return "{\"" + mTag + "\", acquire at " + TimeUtils.formatUptime(mAcquireTime) + "}"; 20563 } 20564 } 20565 20566 /** 20567 * An implementation of IAppTask, that allows an app to manage its own tasks via 20568 * {@link android.app.ActivityManager.AppTask}. We keep track of the callingUid to ensure that 20569 * only the process that calls getAppTasks() can call the AppTask methods. 20570 */ 20571 class AppTaskImpl extends IAppTask.Stub { 20572 private int mTaskId; 20573 private int mCallingUid; 20574 20575 public AppTaskImpl(int taskId, int callingUid) { 20576 mTaskId = taskId; 20577 mCallingUid = callingUid; 20578 } 20579 20580 private void checkCaller() { 20581 if (mCallingUid != Binder.getCallingUid()) { 20582 throw new SecurityException("Caller " + mCallingUid 20583 + " does not match caller of getAppTasks(): " + Binder.getCallingUid()); 20584 } 20585 } 20586 20587 @Override 20588 public void finishAndRemoveTask() { 20589 checkCaller(); 20590 20591 synchronized (ActivityManagerService.this) { 20592 long origId = Binder.clearCallingIdentity(); 20593 try { 20594 if (!removeTaskByIdLocked(mTaskId, false)) { 20595 throw new IllegalArgumentException("Unable to find task ID " + mTaskId); 20596 } 20597 } finally { 20598 Binder.restoreCallingIdentity(origId); 20599 } 20600 } 20601 } 20602 20603 @Override 20604 public ActivityManager.RecentTaskInfo getTaskInfo() { 20605 checkCaller(); 20606 20607 synchronized (ActivityManagerService.this) { 20608 long origId = Binder.clearCallingIdentity(); 20609 try { 20610 TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(mTaskId); 20611 if (tr == null) { 20612 throw new IllegalArgumentException("Unable to find task ID " + mTaskId); 20613 } 20614 return createRecentTaskInfoFromTaskRecord(tr); 20615 } finally { 20616 Binder.restoreCallingIdentity(origId); 20617 } 20618 } 20619 } 20620 20621 @Override 20622 public void moveToFront() { 20623 checkCaller(); 20624 // Will bring task to front if it already has a root activity. 20625 startActivityFromRecentsInner(mTaskId, null); 20626 } 20627 20628 @Override 20629 public int startActivity(IBinder whoThread, String callingPackage, 20630 Intent intent, String resolvedType, Bundle options) { 20631 checkCaller(); 20632 20633 int callingUser = UserHandle.getCallingUserId(); 20634 TaskRecord tr; 20635 IApplicationThread appThread; 20636 synchronized (ActivityManagerService.this) { 20637 tr = mStackSupervisor.anyTaskForIdLocked(mTaskId); 20638 if (tr == null) { 20639 throw new IllegalArgumentException("Unable to find task ID " + mTaskId); 20640 } 20641 appThread = ApplicationThreadNative.asInterface(whoThread); 20642 if (appThread == null) { 20643 throw new IllegalArgumentException("Bad app thread " + appThread); 20644 } 20645 } 20646 return mStackSupervisor.startActivityMayWait(appThread, -1, callingPackage, intent, 20647 resolvedType, null, null, null, null, 0, 0, null, null, 20648 null, options, false, callingUser, null, tr); 20649 } 20650 20651 @Override 20652 public void setExcludeFromRecents(boolean exclude) { 20653 checkCaller(); 20654 20655 synchronized (ActivityManagerService.this) { 20656 long origId = Binder.clearCallingIdentity(); 20657 try { 20658 TaskRecord tr = mStackSupervisor.anyTaskForIdLocked(mTaskId); 20659 if (tr == null) { 20660 throw new IllegalArgumentException("Unable to find task ID " + mTaskId); 20661 } 20662 Intent intent = tr.getBaseIntent(); 20663 if (exclude) { 20664 intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); 20665 } else { 20666 intent.setFlags(intent.getFlags() 20667 & ~Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); 20668 } 20669 } finally { 20670 Binder.restoreCallingIdentity(origId); 20671 } 20672 } 20673 } 20674 } 20675} 20676