1 /* 2 * Copyright (C) 2007 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 17 package android.app; 18 19 import android.os.BatteryStats; 20 import android.os.IBinder; 21 import com.android.internal.app.IUsageStats; 22 import com.android.internal.app.ProcessStats; 23 import com.android.internal.os.PkgUsageStats; 24 import com.android.internal.os.TransferPipe; 25 import com.android.internal.util.FastPrintWriter; 26 27 import android.content.ComponentName; 28 import android.content.Context; 29 import android.content.Intent; 30 import android.content.pm.ApplicationInfo; 31 import android.content.pm.ConfigurationInfo; 32 import android.content.pm.IPackageDataObserver; 33 import android.content.pm.PackageManager; 34 import android.content.pm.UserInfo; 35 import android.content.res.Resources; 36 import android.graphics.Bitmap; 37 import android.graphics.Rect; 38 import android.os.Bundle; 39 import android.os.Debug; 40 import android.os.Handler; 41 import android.os.Parcel; 42 import android.os.Parcelable; 43 import android.os.Process; 44 import android.os.RemoteException; 45 import android.os.ServiceManager; 46 import android.os.SystemProperties; 47 import android.os.UserHandle; 48 import android.text.TextUtils; 49 import android.util.DisplayMetrics; 50 import android.util.Log; 51 import android.util.Slog; 52 53 import java.io.FileDescriptor; 54 import java.io.FileOutputStream; 55 import java.io.PrintWriter; 56 import java.util.HashMap; 57 import java.util.List; 58 import java.util.Map; 59 60 /** 61 * Interact with the overall activities running in the system. 62 */ 63 public class ActivityManager { 64 private static String TAG = "ActivityManager"; 65 private static boolean localLOGV = false; 66 67 private final Context mContext; 68 private final Handler mHandler; 69 70 /** 71 * <a href="{@docRoot}guide/topics/manifest/meta-data-element.html">{@code 72 * <meta-data>}</a> name for a 'home' Activity that declares a package that is to be 73 * uninstalled in lieu of the declaring one. The package named here must be 74 * signed with the same certificate as the one declaring the {@code <meta-data>}. 75 */ 76 public static final String META_HOME_ALTERNATE = "android.app.home.alternate"; 77 78 /** 79 * Result for IActivityManager.startActivity: an error where the 80 * start had to be canceled. 81 * @hide 82 */ 83 public static final int START_CANCELED = -6; 84 85 /** 86 * Result for IActivityManager.startActivity: an error where the 87 * thing being started is not an activity. 88 * @hide 89 */ 90 public static final int START_NOT_ACTIVITY = -5; 91 92 /** 93 * Result for IActivityManager.startActivity: an error where the 94 * caller does not have permission to start the activity. 95 * @hide 96 */ 97 public static final int START_PERMISSION_DENIED = -4; 98 99 /** 100 * Result for IActivityManager.startActivity: an error where the 101 * caller has requested both to forward a result and to receive 102 * a result. 103 * @hide 104 */ 105 public static final int START_FORWARD_AND_REQUEST_CONFLICT = -3; 106 107 /** 108 * Result for IActivityManager.startActivity: an error where the 109 * requested class is not found. 110 * @hide 111 */ 112 public static final int START_CLASS_NOT_FOUND = -2; 113 114 /** 115 * Result for IActivityManager.startActivity: an error where the 116 * given Intent could not be resolved to an activity. 117 * @hide 118 */ 119 public static final int START_INTENT_NOT_RESOLVED = -1; 120 121 /** 122 * Result for IActivityManaqer.startActivity: the activity was started 123 * successfully as normal. 124 * @hide 125 */ 126 public static final int START_SUCCESS = 0; 127 128 /** 129 * Result for IActivityManaqer.startActivity: the caller asked that the Intent not 130 * be executed if it is the recipient, and that is indeed the case. 131 * @hide 132 */ 133 public static final int START_RETURN_INTENT_TO_CALLER = 1; 134 135 /** 136 * Result for IActivityManaqer.startActivity: activity wasn't really started, but 137 * a task was simply brought to the foreground. 138 * @hide 139 */ 140 public static final int START_TASK_TO_FRONT = 2; 141 142 /** 143 * Result for IActivityManaqer.startActivity: activity wasn't really started, but 144 * the given Intent was given to the existing top activity. 145 * @hide 146 */ 147 public static final int START_DELIVERED_TO_TOP = 3; 148 149 /** 150 * Result for IActivityManaqer.startActivity: request was canceled because 151 * app switches are temporarily canceled to ensure the user's last request 152 * (such as pressing home) is performed. 153 * @hide 154 */ 155 public static final int START_SWITCHES_CANCELED = 4; 156 157 /** 158 * Flag for IActivityManaqer.startActivity: do special start mode where 159 * a new activity is launched only if it is needed. 160 * @hide 161 */ 162 public static final int START_FLAG_ONLY_IF_NEEDED = 1<<0; 163 164 /** 165 * Flag for IActivityManaqer.startActivity: launch the app for 166 * debugging. 167 * @hide 168 */ 169 public static final int START_FLAG_DEBUG = 1<<1; 170 171 /** 172 * Flag for IActivityManaqer.startActivity: launch the app for 173 * OpenGL tracing. 174 * @hide 175 */ 176 public static final int START_FLAG_OPENGL_TRACES = 1<<2; 177 178 /** 179 * Flag for IActivityManaqer.startActivity: if the app is being 180 * launched for profiling, automatically stop the profiler once done. 181 * @hide 182 */ 183 public static final int START_FLAG_AUTO_STOP_PROFILER = 1<<3; 184 185 /** 186 * Result for IActivityManaqer.broadcastIntent: success! 187 * @hide 188 */ 189 public static final int BROADCAST_SUCCESS = 0; 190 191 /** 192 * Result for IActivityManaqer.broadcastIntent: attempt to broadcast 193 * a sticky intent without appropriate permission. 194 * @hide 195 */ 196 public static final int BROADCAST_STICKY_CANT_HAVE_PERMISSION = -1; 197 198 /** 199 * Type for IActivityManaqer.getIntentSender: this PendingIntent is 200 * for a sendBroadcast operation. 201 * @hide 202 */ 203 public static final int INTENT_SENDER_BROADCAST = 1; 204 205 /** 206 * Type for IActivityManaqer.getIntentSender: this PendingIntent is 207 * for a startActivity operation. 208 * @hide 209 */ 210 public static final int INTENT_SENDER_ACTIVITY = 2; 211 212 /** 213 * Type for IActivityManaqer.getIntentSender: this PendingIntent is 214 * for an activity result operation. 215 * @hide 216 */ 217 public static final int INTENT_SENDER_ACTIVITY_RESULT = 3; 218 219 /** 220 * Type for IActivityManaqer.getIntentSender: this PendingIntent is 221 * for a startService operation. 222 * @hide 223 */ 224 public static final int INTENT_SENDER_SERVICE = 4; 225 226 /** @hide User operation call: success! */ 227 public static final int USER_OP_SUCCESS = 0; 228 229 /** @hide User operation call: given user id is not known. */ 230 public static final int USER_OP_UNKNOWN_USER = -1; 231 232 /** @hide User operation call: given user id is the current user, can't be stopped. */ 233 public static final int USER_OP_IS_CURRENT = -2; 234 235 /** @hide Process is a persistent system process. */ 236 public static final int PROCESS_STATE_PERSISTENT = 0; 237 238 /** @hide Process is a persistent system process and is doing UI. */ 239 public static final int PROCESS_STATE_PERSISTENT_UI = 1; 240 241 /** @hide Process is hosting the current top activities. Note that this covers 242 * all activities that are visible to the user. */ 243 public static final int PROCESS_STATE_TOP = 2; 244 245 /** @hide Process is important to the user, and something they are aware of. */ 246 public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 3; 247 248 /** @hide Process is important to the user, but not something they are aware of. */ 249 public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 4; 250 251 /** @hide Process is in the background running a backup/restore operation. */ 252 public static final int PROCESS_STATE_BACKUP = 5; 253 254 /** @hide Process is in the background, but it can't restore its state so we want 255 * to try to avoid killing it. */ 256 public static final int PROCESS_STATE_HEAVY_WEIGHT = 6; 257 258 /** @hide Process is in the background running a service. Unlike oom_adj, this level 259 * is used for both the normal running in background state and the executing 260 * operations state. */ 261 public static final int PROCESS_STATE_SERVICE = 7; 262 263 /** @hide Process is in the background running a receiver. Note that from the 264 * perspective of oom_adj receivers run at a higher foreground level, but for our 265 * prioritization here that is not necessary and putting them below services means 266 * many fewer changes in some process states as they receive broadcasts. */ 267 public static final int PROCESS_STATE_RECEIVER = 8; 268 269 /** @hide Process is in the background but hosts the home activity. */ 270 public static final int PROCESS_STATE_HOME = 9; 271 272 /** @hide Process is in the background but hosts the last shown activity. */ 273 public static final int PROCESS_STATE_LAST_ACTIVITY = 10; 274 275 /** @hide Process is being cached for later use and contains activities. */ 276 public static final int PROCESS_STATE_CACHED_ACTIVITY = 11; 277 278 /** @hide Process is being cached for later use and is a client of another cached 279 * process that contains activities. */ 280 public static final int PROCESS_STATE_CACHED_ACTIVITY_CLIENT = 12; 281 282 /** @hide Process is being cached for later use and is empty. */ 283 public static final int PROCESS_STATE_CACHED_EMPTY = 13; 284 ActivityManager(Context context, Handler handler)285 /*package*/ ActivityManager(Context context, Handler handler) { 286 mContext = context; 287 mHandler = handler; 288 } 289 290 /** 291 * Screen compatibility mode: the application most always run in 292 * compatibility mode. 293 * @hide 294 */ 295 public static final int COMPAT_MODE_ALWAYS = -1; 296 297 /** 298 * Screen compatibility mode: the application can never run in 299 * compatibility mode. 300 * @hide 301 */ 302 public static final int COMPAT_MODE_NEVER = -2; 303 304 /** 305 * Screen compatibility mode: unknown. 306 * @hide 307 */ 308 public static final int COMPAT_MODE_UNKNOWN = -3; 309 310 /** 311 * Screen compatibility mode: the application currently has compatibility 312 * mode disabled. 313 * @hide 314 */ 315 public static final int COMPAT_MODE_DISABLED = 0; 316 317 /** 318 * Screen compatibility mode: the application currently has compatibility 319 * mode enabled. 320 * @hide 321 */ 322 public static final int COMPAT_MODE_ENABLED = 1; 323 324 /** 325 * Screen compatibility mode: request to toggle the application's 326 * compatibility mode. 327 * @hide 328 */ 329 public static final int COMPAT_MODE_TOGGLE = 2; 330 331 /** @hide */ getFrontActivityScreenCompatMode()332 public int getFrontActivityScreenCompatMode() { 333 try { 334 return ActivityManagerNative.getDefault().getFrontActivityScreenCompatMode(); 335 } catch (RemoteException e) { 336 // System dead, we will be dead too soon! 337 return 0; 338 } 339 } 340 341 /** @hide */ setFrontActivityScreenCompatMode(int mode)342 public void setFrontActivityScreenCompatMode(int mode) { 343 try { 344 ActivityManagerNative.getDefault().setFrontActivityScreenCompatMode(mode); 345 } catch (RemoteException e) { 346 // System dead, we will be dead too soon! 347 } 348 } 349 350 /** @hide */ getPackageScreenCompatMode(String packageName)351 public int getPackageScreenCompatMode(String packageName) { 352 try { 353 return ActivityManagerNative.getDefault().getPackageScreenCompatMode(packageName); 354 } catch (RemoteException e) { 355 // System dead, we will be dead too soon! 356 return 0; 357 } 358 } 359 360 /** @hide */ setPackageScreenCompatMode(String packageName, int mode)361 public void setPackageScreenCompatMode(String packageName, int mode) { 362 try { 363 ActivityManagerNative.getDefault().setPackageScreenCompatMode(packageName, mode); 364 } catch (RemoteException e) { 365 // System dead, we will be dead too soon! 366 } 367 } 368 369 /** @hide */ getPackageAskScreenCompat(String packageName)370 public boolean getPackageAskScreenCompat(String packageName) { 371 try { 372 return ActivityManagerNative.getDefault().getPackageAskScreenCompat(packageName); 373 } catch (RemoteException e) { 374 // System dead, we will be dead too soon! 375 return false; 376 } 377 } 378 379 /** @hide */ setPackageAskScreenCompat(String packageName, boolean ask)380 public void setPackageAskScreenCompat(String packageName, boolean ask) { 381 try { 382 ActivityManagerNative.getDefault().setPackageAskScreenCompat(packageName, ask); 383 } catch (RemoteException e) { 384 // System dead, we will be dead too soon! 385 } 386 } 387 388 /** 389 * Return the approximate per-application memory class of the current 390 * device. This gives you an idea of how hard a memory limit you should 391 * impose on your application to let the overall system work best. The 392 * returned value is in megabytes; the baseline Android memory class is 393 * 16 (which happens to be the Java heap limit of those devices); some 394 * device with more memory may return 24 or even higher numbers. 395 */ getMemoryClass()396 public int getMemoryClass() { 397 return staticGetMemoryClass(); 398 } 399 400 /** @hide */ staticGetMemoryClass()401 static public int staticGetMemoryClass() { 402 // Really brain dead right now -- just take this from the configured 403 // vm heap size, and assume it is in megabytes and thus ends with "m". 404 String vmHeapSize = SystemProperties.get("dalvik.vm.heapgrowthlimit", ""); 405 if (vmHeapSize != null && !"".equals(vmHeapSize)) { 406 return Integer.parseInt(vmHeapSize.substring(0, vmHeapSize.length()-1)); 407 } 408 return staticGetLargeMemoryClass(); 409 } 410 411 /** 412 * Return the approximate per-application memory class of the current 413 * device when an application is running with a large heap. This is the 414 * space available for memory-intensive applications; most applications 415 * should not need this amount of memory, and should instead stay with the 416 * {@link #getMemoryClass()} limit. The returned value is in megabytes. 417 * This may be the same size as {@link #getMemoryClass()} on memory 418 * constrained devices, or it may be significantly larger on devices with 419 * a large amount of available RAM. 420 * 421 * <p>The is the size of the application's Dalvik heap if it has 422 * specified <code>android:largeHeap="true"</code> in its manifest. 423 */ getLargeMemoryClass()424 public int getLargeMemoryClass() { 425 return staticGetLargeMemoryClass(); 426 } 427 428 /** @hide */ staticGetLargeMemoryClass()429 static public int staticGetLargeMemoryClass() { 430 // Really brain dead right now -- just take this from the configured 431 // vm heap size, and assume it is in megabytes and thus ends with "m". 432 String vmHeapSize = SystemProperties.get("dalvik.vm.heapsize", "16m"); 433 return Integer.parseInt(vmHeapSize.substring(0, vmHeapSize.length()-1)); 434 } 435 436 /** 437 * Returns true if this is a low-RAM device. Exactly whether a device is low-RAM 438 * is ultimately up to the device configuration, but currently it generally means 439 * something in the class of a 512MB device with about a 800x480 or less screen. 440 * This is mostly intended to be used by apps to determine whether they should turn 441 * off certain features that require more RAM. 442 */ isLowRamDevice()443 public boolean isLowRamDevice() { 444 return isLowRamDeviceStatic(); 445 } 446 447 /** @hide */ isLowRamDeviceStatic()448 public static boolean isLowRamDeviceStatic() { 449 return "true".equals(SystemProperties.get("ro.config.low_ram", "false")); 450 } 451 452 /** 453 * Used by persistent processes to determine if they are running on a 454 * higher-end device so should be okay using hardware drawing acceleration 455 * (which tends to consume a lot more RAM). 456 * @hide 457 */ isHighEndGfx()458 static public boolean isHighEndGfx() { 459 return !isLowRamDeviceStatic() && 460 !Resources.getSystem().getBoolean(com.android.internal.R.bool.config_avoidGfxAccel); 461 } 462 463 /** 464 * Information you can retrieve about tasks that the user has most recently 465 * started or visited. 466 */ 467 public static class RecentTaskInfo implements Parcelable { 468 /** 469 * If this task is currently running, this is the identifier for it. 470 * If it is not running, this will be -1. 471 */ 472 public int id; 473 474 /** 475 * The true identifier of this task, valid even if it is not running. 476 */ 477 public int persistentId; 478 479 /** 480 * The original Intent used to launch the task. You can use this 481 * Intent to re-launch the task (if it is no longer running) or bring 482 * the current task to the front. 483 */ 484 public Intent baseIntent; 485 486 /** 487 * If this task was started from an alias, this is the actual 488 * activity component that was initially started; the component of 489 * the baseIntent in this case is the name of the actual activity 490 * implementation that the alias referred to. Otherwise, this is null. 491 */ 492 public ComponentName origActivity; 493 494 /** 495 * Description of the task's last state. 496 */ 497 public CharSequence description; 498 499 /** 500 * The id of the ActivityStack this Task was on most recently. 501 * @hide 502 */ 503 public int stackId; 504 RecentTaskInfo()505 public RecentTaskInfo() { 506 } 507 508 @Override describeContents()509 public int describeContents() { 510 return 0; 511 } 512 513 @Override writeToParcel(Parcel dest, int flags)514 public void writeToParcel(Parcel dest, int flags) { 515 dest.writeInt(id); 516 dest.writeInt(persistentId); 517 if (baseIntent != null) { 518 dest.writeInt(1); 519 baseIntent.writeToParcel(dest, 0); 520 } else { 521 dest.writeInt(0); 522 } 523 ComponentName.writeToParcel(origActivity, dest); 524 TextUtils.writeToParcel(description, dest, 525 Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 526 dest.writeInt(stackId); 527 } 528 readFromParcel(Parcel source)529 public void readFromParcel(Parcel source) { 530 id = source.readInt(); 531 persistentId = source.readInt(); 532 if (source.readInt() != 0) { 533 baseIntent = Intent.CREATOR.createFromParcel(source); 534 } else { 535 baseIntent = null; 536 } 537 origActivity = ComponentName.readFromParcel(source); 538 description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source); 539 stackId = source.readInt(); 540 } 541 542 public static final Creator<RecentTaskInfo> CREATOR 543 = new Creator<RecentTaskInfo>() { 544 public RecentTaskInfo createFromParcel(Parcel source) { 545 return new RecentTaskInfo(source); 546 } 547 public RecentTaskInfo[] newArray(int size) { 548 return new RecentTaskInfo[size]; 549 } 550 }; 551 RecentTaskInfo(Parcel source)552 private RecentTaskInfo(Parcel source) { 553 readFromParcel(source); 554 } 555 } 556 557 /** 558 * Flag for use with {@link #getRecentTasks}: return all tasks, even those 559 * that have set their 560 * {@link android.content.Intent#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS} flag. 561 */ 562 public static final int RECENT_WITH_EXCLUDED = 0x0001; 563 564 /** 565 * Provides a list that does not contain any 566 * recent tasks that currently are not available to the user. 567 */ 568 public static final int RECENT_IGNORE_UNAVAILABLE = 0x0002; 569 570 /** 571 * Return a list of the tasks that the user has recently launched, with 572 * the most recent being first and older ones after in order. 573 * 574 * <p><b>Note: this method is only intended for debugging and presenting 575 * task management user interfaces</b>. This should never be used for 576 * core logic in an application, such as deciding between different 577 * behaviors based on the information found here. Such uses are 578 * <em>not</em> supported, and will likely break in the future. For 579 * example, if multiple applications can be actively running at the 580 * same time, assumptions made about the meaning of the data here for 581 * purposes of control flow will be incorrect.</p> 582 * 583 * @param maxNum The maximum number of entries to return in the list. The 584 * actual number returned may be smaller, depending on how many tasks the 585 * user has started and the maximum number the system can remember. 586 * @param flags Information about what to return. May be any combination 587 * of {@link #RECENT_WITH_EXCLUDED} and {@link #RECENT_IGNORE_UNAVAILABLE}. 588 * 589 * @return Returns a list of RecentTaskInfo records describing each of 590 * the recent tasks. 591 * 592 * @throws SecurityException Throws SecurityException if the caller does 593 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 594 */ getRecentTasks(int maxNum, int flags)595 public List<RecentTaskInfo> getRecentTasks(int maxNum, int flags) 596 throws SecurityException { 597 try { 598 return ActivityManagerNative.getDefault().getRecentTasks(maxNum, 599 flags, UserHandle.myUserId()); 600 } catch (RemoteException e) { 601 // System dead, we will be dead too soon! 602 return null; 603 } 604 } 605 606 /** 607 * Same as {@link #getRecentTasks(int, int)} but returns the recent tasks for a 608 * specific user. It requires holding 609 * the {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} permission. 610 * @param maxNum The maximum number of entries to return in the list. The 611 * actual number returned may be smaller, depending on how many tasks the 612 * user has started and the maximum number the system can remember. 613 * @param flags Information about what to return. May be any combination 614 * of {@link #RECENT_WITH_EXCLUDED} and {@link #RECENT_IGNORE_UNAVAILABLE}. 615 * 616 * @return Returns a list of RecentTaskInfo records describing each of 617 * the recent tasks. 618 * 619 * @throws SecurityException Throws SecurityException if the caller does 620 * not hold the {@link android.Manifest.permission#GET_TASKS} or the 621 * {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} permissions. 622 * @hide 623 */ getRecentTasksForUser(int maxNum, int flags, int userId)624 public List<RecentTaskInfo> getRecentTasksForUser(int maxNum, int flags, int userId) 625 throws SecurityException { 626 try { 627 return ActivityManagerNative.getDefault().getRecentTasks(maxNum, 628 flags, userId); 629 } catch (RemoteException e) { 630 // System dead, we will be dead too soon! 631 return null; 632 } 633 } 634 635 /** 636 * Information you can retrieve about a particular task that is currently 637 * "running" in the system. Note that a running task does not mean the 638 * given task actually has a process it is actively running in; it simply 639 * means that the user has gone to it and never closed it, but currently 640 * the system may have killed its process and is only holding on to its 641 * last state in order to restart it when the user returns. 642 */ 643 public static class RunningTaskInfo implements Parcelable { 644 /** 645 * A unique identifier for this task. 646 */ 647 public int id; 648 649 /** 650 * The component launched as the first activity in the task. This can 651 * be considered the "application" of this task. 652 */ 653 public ComponentName baseActivity; 654 655 /** 656 * The activity component at the top of the history stack of the task. 657 * This is what the user is currently doing. 658 */ 659 public ComponentName topActivity; 660 661 /** 662 * Thumbnail representation of the task's current state. Currently 663 * always null. 664 */ 665 public Bitmap thumbnail; 666 667 /** 668 * Description of the task's current state. 669 */ 670 public CharSequence description; 671 672 /** 673 * Number of activities in this task. 674 */ 675 public int numActivities; 676 677 /** 678 * Number of activities that are currently running (not stopped 679 * and persisted) in this task. 680 */ 681 public int numRunning; 682 683 /** 684 * Last time task was run. For sorting. 685 * @hide 686 */ 687 public long lastActiveTime; 688 RunningTaskInfo()689 public RunningTaskInfo() { 690 } 691 describeContents()692 public int describeContents() { 693 return 0; 694 } 695 writeToParcel(Parcel dest, int flags)696 public void writeToParcel(Parcel dest, int flags) { 697 dest.writeInt(id); 698 ComponentName.writeToParcel(baseActivity, dest); 699 ComponentName.writeToParcel(topActivity, dest); 700 if (thumbnail != null) { 701 dest.writeInt(1); 702 thumbnail.writeToParcel(dest, 0); 703 } else { 704 dest.writeInt(0); 705 } 706 TextUtils.writeToParcel(description, dest, 707 Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 708 dest.writeInt(numActivities); 709 dest.writeInt(numRunning); 710 } 711 readFromParcel(Parcel source)712 public void readFromParcel(Parcel source) { 713 id = source.readInt(); 714 baseActivity = ComponentName.readFromParcel(source); 715 topActivity = ComponentName.readFromParcel(source); 716 if (source.readInt() != 0) { 717 thumbnail = Bitmap.CREATOR.createFromParcel(source); 718 } else { 719 thumbnail = null; 720 } 721 description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source); 722 numActivities = source.readInt(); 723 numRunning = source.readInt(); 724 } 725 726 public static final Creator<RunningTaskInfo> CREATOR = new Creator<RunningTaskInfo>() { 727 public RunningTaskInfo createFromParcel(Parcel source) { 728 return new RunningTaskInfo(source); 729 } 730 public RunningTaskInfo[] newArray(int size) { 731 return new RunningTaskInfo[size]; 732 } 733 }; 734 RunningTaskInfo(Parcel source)735 private RunningTaskInfo(Parcel source) { 736 readFromParcel(source); 737 } 738 } 739 740 /** 741 * Return a list of the tasks that are currently running, with 742 * the most recent being first and older ones after in order. Note that 743 * "running" does not mean any of the task's code is currently loaded or 744 * activity -- the task may have been frozen by the system, so that it 745 * can be restarted in its previous state when next brought to the 746 * foreground. 747 * 748 * @param maxNum The maximum number of entries to return in the list. The 749 * actual number returned may be smaller, depending on how many tasks the 750 * user has started. 751 * 752 * @param flags Optional flags 753 * @param receiver Optional receiver for delayed thumbnails 754 * 755 * @return Returns a list of RunningTaskInfo records describing each of 756 * the running tasks. 757 * 758 * Some thumbnails may not be available at the time of this call. The optional 759 * receiver may be used to receive those thumbnails. 760 * 761 * @throws SecurityException Throws SecurityException if the caller does 762 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 763 * 764 * @hide 765 */ getRunningTasks(int maxNum, int flags, IThumbnailReceiver receiver)766 public List<RunningTaskInfo> getRunningTasks(int maxNum, int flags, IThumbnailReceiver receiver) 767 throws SecurityException { 768 try { 769 return ActivityManagerNative.getDefault().getTasks(maxNum, flags, receiver); 770 } catch (RemoteException e) { 771 // System dead, we will be dead too soon! 772 return null; 773 } 774 } 775 776 /** 777 * Return a list of the tasks that are currently running, with 778 * the most recent being first and older ones after in order. Note that 779 * "running" does not mean any of the task's code is currently loaded or 780 * activity -- the task may have been frozen by the system, so that it 781 * can be restarted in its previous state when next brought to the 782 * foreground. 783 * 784 * <p><b>Note: this method is only intended for debugging and presenting 785 * task management user interfaces</b>. This should never be used for 786 * core logic in an application, such as deciding between different 787 * behaviors based on the information found here. Such uses are 788 * <em>not</em> supported, and will likely break in the future. For 789 * example, if multiple applications can be actively running at the 790 * same time, assumptions made about the meaning of the data here for 791 * purposes of control flow will be incorrect.</p> 792 * 793 * @param maxNum The maximum number of entries to return in the list. The 794 * actual number returned may be smaller, depending on how many tasks the 795 * user has started. 796 * 797 * @return Returns a list of RunningTaskInfo records describing each of 798 * the running tasks. 799 * 800 * @throws SecurityException Throws SecurityException if the caller does 801 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 802 */ getRunningTasks(int maxNum)803 public List<RunningTaskInfo> getRunningTasks(int maxNum) 804 throws SecurityException { 805 return getRunningTasks(maxNum, 0, null); 806 } 807 808 /** 809 * Remove some end of a task's activity stack that is not part of 810 * the main application. The selected activities will be finished, so 811 * they are no longer part of the main task. 812 * 813 * @param taskId The identifier of the task. 814 * @param subTaskIndex The number of the sub-task; this corresponds 815 * to the index of the thumbnail returned by {@link #getTaskThumbnails(int)}. 816 * @return Returns true if the sub-task was found and was removed. 817 * 818 * @hide 819 */ removeSubTask(int taskId, int subTaskIndex)820 public boolean removeSubTask(int taskId, int subTaskIndex) 821 throws SecurityException { 822 try { 823 return ActivityManagerNative.getDefault().removeSubTask(taskId, subTaskIndex); 824 } catch (RemoteException e) { 825 // System dead, we will be dead too soon! 826 return false; 827 } 828 } 829 830 /** 831 * If set, the process of the root activity of the task will be killed 832 * as part of removing the task. 833 * @hide 834 */ 835 public static final int REMOVE_TASK_KILL_PROCESS = 0x0001; 836 837 /** 838 * Completely remove the given task. 839 * 840 * @param taskId Identifier of the task to be removed. 841 * @param flags Additional operational flags. May be 0 or 842 * {@link #REMOVE_TASK_KILL_PROCESS}. 843 * @return Returns true if the given task was found and removed. 844 * 845 * @hide 846 */ removeTask(int taskId, int flags)847 public boolean removeTask(int taskId, int flags) 848 throws SecurityException { 849 try { 850 return ActivityManagerNative.getDefault().removeTask(taskId, flags); 851 } catch (RemoteException e) { 852 // System dead, we will be dead too soon! 853 return false; 854 } 855 } 856 857 /** @hide */ 858 public static class TaskThumbnails implements Parcelable { 859 public Bitmap mainThumbnail; 860 861 public int numSubThumbbails; 862 863 /** @hide */ 864 public IThumbnailRetriever retriever; 865 TaskThumbnails()866 public TaskThumbnails() { 867 } 868 getSubThumbnail(int index)869 public Bitmap getSubThumbnail(int index) { 870 try { 871 return retriever.getThumbnail(index); 872 } catch (RemoteException e) { 873 return null; 874 } 875 } 876 describeContents()877 public int describeContents() { 878 return 0; 879 } 880 writeToParcel(Parcel dest, int flags)881 public void writeToParcel(Parcel dest, int flags) { 882 if (mainThumbnail != null) { 883 dest.writeInt(1); 884 mainThumbnail.writeToParcel(dest, 0); 885 } else { 886 dest.writeInt(0); 887 } 888 dest.writeInt(numSubThumbbails); 889 dest.writeStrongInterface(retriever); 890 } 891 readFromParcel(Parcel source)892 public void readFromParcel(Parcel source) { 893 if (source.readInt() != 0) { 894 mainThumbnail = Bitmap.CREATOR.createFromParcel(source); 895 } else { 896 mainThumbnail = null; 897 } 898 numSubThumbbails = source.readInt(); 899 retriever = IThumbnailRetriever.Stub.asInterface(source.readStrongBinder()); 900 } 901 902 public static final Creator<TaskThumbnails> CREATOR = new Creator<TaskThumbnails>() { 903 public TaskThumbnails createFromParcel(Parcel source) { 904 return new TaskThumbnails(source); 905 } 906 public TaskThumbnails[] newArray(int size) { 907 return new TaskThumbnails[size]; 908 } 909 }; 910 TaskThumbnails(Parcel source)911 private TaskThumbnails(Parcel source) { 912 readFromParcel(source); 913 } 914 } 915 916 /** @hide */ getTaskThumbnails(int id)917 public TaskThumbnails getTaskThumbnails(int id) throws SecurityException { 918 try { 919 return ActivityManagerNative.getDefault().getTaskThumbnails(id); 920 } catch (RemoteException e) { 921 // System dead, we will be dead too soon! 922 return null; 923 } 924 } 925 926 /** @hide */ getTaskTopThumbnail(int id)927 public Bitmap getTaskTopThumbnail(int id) throws SecurityException { 928 try { 929 return ActivityManagerNative.getDefault().getTaskTopThumbnail(id); 930 } catch (RemoteException e) { 931 // System dead, we will be dead too soon! 932 return null; 933 } 934 } 935 936 /** 937 * Flag for {@link #moveTaskToFront(int, int)}: also move the "home" 938 * activity along with the task, so it is positioned immediately behind 939 * the task. 940 */ 941 public static final int MOVE_TASK_WITH_HOME = 0x00000001; 942 943 /** 944 * Flag for {@link #moveTaskToFront(int, int)}: don't count this as a 945 * user-instigated action, so the current activity will not receive a 946 * hint that the user is leaving. 947 */ 948 public static final int MOVE_TASK_NO_USER_ACTION = 0x00000002; 949 950 /** 951 * Equivalent to calling {@link #moveTaskToFront(int, int, Bundle)} 952 * with a null options argument. 953 * 954 * @param taskId The identifier of the task to be moved, as found in 955 * {@link RunningTaskInfo} or {@link RecentTaskInfo}. 956 * @param flags Additional operational flags, 0 or more of 957 * {@link #MOVE_TASK_WITH_HOME}, {@link #MOVE_TASK_NO_USER_ACTION}. 958 */ moveTaskToFront(int taskId, int flags)959 public void moveTaskToFront(int taskId, int flags) { 960 moveTaskToFront(taskId, flags, null); 961 } 962 963 /** 964 * Ask that the task associated with a given task ID be moved to the 965 * front of the stack, so it is now visible to the user. Requires that 966 * the caller hold permission {@link android.Manifest.permission#REORDER_TASKS} 967 * or a SecurityException will be thrown. 968 * 969 * @param taskId The identifier of the task to be moved, as found in 970 * {@link RunningTaskInfo} or {@link RecentTaskInfo}. 971 * @param flags Additional operational flags, 0 or more of 972 * {@link #MOVE_TASK_WITH_HOME}, {@link #MOVE_TASK_NO_USER_ACTION}. 973 * @param options Additional options for the operation, either null or 974 * as per {@link Context#startActivity(Intent, android.os.Bundle) 975 * Context.startActivity(Intent, Bundle)}. 976 */ moveTaskToFront(int taskId, int flags, Bundle options)977 public void moveTaskToFront(int taskId, int flags, Bundle options) { 978 try { 979 ActivityManagerNative.getDefault().moveTaskToFront(taskId, flags, options); 980 } catch (RemoteException e) { 981 // System dead, we will be dead too soon! 982 } 983 } 984 985 /** 986 * Information you can retrieve about a particular Service that is 987 * currently running in the system. 988 */ 989 public static class RunningServiceInfo implements Parcelable { 990 /** 991 * The service component. 992 */ 993 public ComponentName service; 994 995 /** 996 * If non-zero, this is the process the service is running in. 997 */ 998 public int pid; 999 1000 /** 1001 * The UID that owns this service. 1002 */ 1003 public int uid; 1004 1005 /** 1006 * The name of the process this service runs in. 1007 */ 1008 public String process; 1009 1010 /** 1011 * Set to true if the service has asked to run as a foreground process. 1012 */ 1013 public boolean foreground; 1014 1015 /** 1016 * The time when the service was first made active, either by someone 1017 * starting or binding to it. This 1018 * is in units of {@link android.os.SystemClock#elapsedRealtime()}. 1019 */ 1020 public long activeSince; 1021 1022 /** 1023 * Set to true if this service has been explicitly started. 1024 */ 1025 public boolean started; 1026 1027 /** 1028 * Number of clients connected to the service. 1029 */ 1030 public int clientCount; 1031 1032 /** 1033 * Number of times the service's process has crashed while the service 1034 * is running. 1035 */ 1036 public int crashCount; 1037 1038 /** 1039 * The time when there was last activity in the service (either 1040 * explicit requests to start it or clients binding to it). This 1041 * is in units of {@link android.os.SystemClock#uptimeMillis()}. 1042 */ 1043 public long lastActivityTime; 1044 1045 /** 1046 * If non-zero, this service is not currently running, but scheduled to 1047 * restart at the given time. 1048 */ 1049 public long restarting; 1050 1051 /** 1052 * Bit for {@link #flags}: set if this service has been 1053 * explicitly started. 1054 */ 1055 public static final int FLAG_STARTED = 1<<0; 1056 1057 /** 1058 * Bit for {@link #flags}: set if the service has asked to 1059 * run as a foreground process. 1060 */ 1061 public static final int FLAG_FOREGROUND = 1<<1; 1062 1063 /** 1064 * Bit for {@link #flags): set if the service is running in a 1065 * core system process. 1066 */ 1067 public static final int FLAG_SYSTEM_PROCESS = 1<<2; 1068 1069 /** 1070 * Bit for {@link #flags): set if the service is running in a 1071 * persistent process. 1072 */ 1073 public static final int FLAG_PERSISTENT_PROCESS = 1<<3; 1074 1075 /** 1076 * Running flags. 1077 */ 1078 public int flags; 1079 1080 /** 1081 * For special services that are bound to by system code, this is 1082 * the package that holds the binding. 1083 */ 1084 public String clientPackage; 1085 1086 /** 1087 * For special services that are bound to by system code, this is 1088 * a string resource providing a user-visible label for who the 1089 * client is. 1090 */ 1091 public int clientLabel; 1092 RunningServiceInfo()1093 public RunningServiceInfo() { 1094 } 1095 describeContents()1096 public int describeContents() { 1097 return 0; 1098 } 1099 writeToParcel(Parcel dest, int flags)1100 public void writeToParcel(Parcel dest, int flags) { 1101 ComponentName.writeToParcel(service, dest); 1102 dest.writeInt(pid); 1103 dest.writeInt(uid); 1104 dest.writeString(process); 1105 dest.writeInt(foreground ? 1 : 0); 1106 dest.writeLong(activeSince); 1107 dest.writeInt(started ? 1 : 0); 1108 dest.writeInt(clientCount); 1109 dest.writeInt(crashCount); 1110 dest.writeLong(lastActivityTime); 1111 dest.writeLong(restarting); 1112 dest.writeInt(this.flags); 1113 dest.writeString(clientPackage); 1114 dest.writeInt(clientLabel); 1115 } 1116 readFromParcel(Parcel source)1117 public void readFromParcel(Parcel source) { 1118 service = ComponentName.readFromParcel(source); 1119 pid = source.readInt(); 1120 uid = source.readInt(); 1121 process = source.readString(); 1122 foreground = source.readInt() != 0; 1123 activeSince = source.readLong(); 1124 started = source.readInt() != 0; 1125 clientCount = source.readInt(); 1126 crashCount = source.readInt(); 1127 lastActivityTime = source.readLong(); 1128 restarting = source.readLong(); 1129 flags = source.readInt(); 1130 clientPackage = source.readString(); 1131 clientLabel = source.readInt(); 1132 } 1133 1134 public static final Creator<RunningServiceInfo> CREATOR = new Creator<RunningServiceInfo>() { 1135 public RunningServiceInfo createFromParcel(Parcel source) { 1136 return new RunningServiceInfo(source); 1137 } 1138 public RunningServiceInfo[] newArray(int size) { 1139 return new RunningServiceInfo[size]; 1140 } 1141 }; 1142 RunningServiceInfo(Parcel source)1143 private RunningServiceInfo(Parcel source) { 1144 readFromParcel(source); 1145 } 1146 } 1147 1148 /** 1149 * Return a list of the services that are currently running. 1150 * 1151 * <p><b>Note: this method is only intended for debugging or implementing 1152 * service management type user interfaces.</b></p> 1153 * 1154 * @param maxNum The maximum number of entries to return in the list. The 1155 * actual number returned may be smaller, depending on how many services 1156 * are running. 1157 * 1158 * @return Returns a list of RunningServiceInfo records describing each of 1159 * the running tasks. 1160 */ getRunningServices(int maxNum)1161 public List<RunningServiceInfo> getRunningServices(int maxNum) 1162 throws SecurityException { 1163 try { 1164 return ActivityManagerNative.getDefault() 1165 .getServices(maxNum, 0); 1166 } catch (RemoteException e) { 1167 // System dead, we will be dead too soon! 1168 return null; 1169 } 1170 } 1171 1172 /** 1173 * Returns a PendingIntent you can start to show a control panel for the 1174 * given running service. If the service does not have a control panel, 1175 * null is returned. 1176 */ getRunningServiceControlPanel(ComponentName service)1177 public PendingIntent getRunningServiceControlPanel(ComponentName service) 1178 throws SecurityException { 1179 try { 1180 return ActivityManagerNative.getDefault() 1181 .getRunningServiceControlPanel(service); 1182 } catch (RemoteException e) { 1183 // System dead, we will be dead too soon! 1184 return null; 1185 } 1186 } 1187 1188 /** 1189 * Information you can retrieve about the available memory through 1190 * {@link ActivityManager#getMemoryInfo}. 1191 */ 1192 public static class MemoryInfo implements Parcelable { 1193 /** 1194 * The available memory on the system. This number should not 1195 * be considered absolute: due to the nature of the kernel, a significant 1196 * portion of this memory is actually in use and needed for the overall 1197 * system to run well. 1198 */ 1199 public long availMem; 1200 1201 /** 1202 * The total memory accessible by the kernel. This is basically the 1203 * RAM size of the device, not including below-kernel fixed allocations 1204 * like DMA buffers, RAM for the baseband CPU, etc. 1205 */ 1206 public long totalMem; 1207 1208 /** 1209 * The threshold of {@link #availMem} at which we consider memory to be 1210 * low and start killing background services and other non-extraneous 1211 * processes. 1212 */ 1213 public long threshold; 1214 1215 /** 1216 * Set to true if the system considers itself to currently be in a low 1217 * memory situation. 1218 */ 1219 public boolean lowMemory; 1220 1221 /** @hide */ 1222 public long hiddenAppThreshold; 1223 /** @hide */ 1224 public long secondaryServerThreshold; 1225 /** @hide */ 1226 public long visibleAppThreshold; 1227 /** @hide */ 1228 public long foregroundAppThreshold; 1229 MemoryInfo()1230 public MemoryInfo() { 1231 } 1232 describeContents()1233 public int describeContents() { 1234 return 0; 1235 } 1236 writeToParcel(Parcel dest, int flags)1237 public void writeToParcel(Parcel dest, int flags) { 1238 dest.writeLong(availMem); 1239 dest.writeLong(totalMem); 1240 dest.writeLong(threshold); 1241 dest.writeInt(lowMemory ? 1 : 0); 1242 dest.writeLong(hiddenAppThreshold); 1243 dest.writeLong(secondaryServerThreshold); 1244 dest.writeLong(visibleAppThreshold); 1245 dest.writeLong(foregroundAppThreshold); 1246 } 1247 readFromParcel(Parcel source)1248 public void readFromParcel(Parcel source) { 1249 availMem = source.readLong(); 1250 totalMem = source.readLong(); 1251 threshold = source.readLong(); 1252 lowMemory = source.readInt() != 0; 1253 hiddenAppThreshold = source.readLong(); 1254 secondaryServerThreshold = source.readLong(); 1255 visibleAppThreshold = source.readLong(); 1256 foregroundAppThreshold = source.readLong(); 1257 } 1258 1259 public static final Creator<MemoryInfo> CREATOR 1260 = new Creator<MemoryInfo>() { 1261 public MemoryInfo createFromParcel(Parcel source) { 1262 return new MemoryInfo(source); 1263 } 1264 public MemoryInfo[] newArray(int size) { 1265 return new MemoryInfo[size]; 1266 } 1267 }; 1268 MemoryInfo(Parcel source)1269 private MemoryInfo(Parcel source) { 1270 readFromParcel(source); 1271 } 1272 } 1273 1274 /** 1275 * Return general information about the memory state of the system. This 1276 * can be used to help decide how to manage your own memory, though note 1277 * that polling is not recommended and 1278 * {@link android.content.ComponentCallbacks2#onTrimMemory(int) 1279 * ComponentCallbacks2.onTrimMemory(int)} is the preferred way to do this. 1280 * Also see {@link #getMyMemoryState} for how to retrieve the current trim 1281 * level of your process as needed, which gives a better hint for how to 1282 * manage its memory. 1283 */ getMemoryInfo(MemoryInfo outInfo)1284 public void getMemoryInfo(MemoryInfo outInfo) { 1285 try { 1286 ActivityManagerNative.getDefault().getMemoryInfo(outInfo); 1287 } catch (RemoteException e) { 1288 } 1289 } 1290 1291 /** 1292 * Information you can retrieve about the WindowManager StackBox hierarchy. 1293 * @hide 1294 */ 1295 public static class StackBoxInfo implements Parcelable { 1296 public int stackBoxId; 1297 public float weight; 1298 public boolean vertical; 1299 public Rect bounds; 1300 public StackBoxInfo[] children; 1301 public int stackId; 1302 public StackInfo stack; 1303 1304 @Override describeContents()1305 public int describeContents() { 1306 return 0; 1307 } 1308 1309 @Override writeToParcel(Parcel dest, int flags)1310 public void writeToParcel(Parcel dest, int flags) { 1311 dest.writeInt(stackBoxId); 1312 dest.writeFloat(weight); 1313 dest.writeInt(vertical ? 1 : 0); 1314 bounds.writeToParcel(dest, flags); 1315 dest.writeInt(stackId); 1316 if (children != null) { 1317 children[0].writeToParcel(dest, flags); 1318 children[1].writeToParcel(dest, flags); 1319 } else { 1320 stack.writeToParcel(dest, flags); 1321 } 1322 } 1323 readFromParcel(Parcel source)1324 public void readFromParcel(Parcel source) { 1325 stackBoxId = source.readInt(); 1326 weight = source.readFloat(); 1327 vertical = source.readInt() == 1; 1328 bounds = Rect.CREATOR.createFromParcel(source); 1329 stackId = source.readInt(); 1330 if (stackId == -1) { 1331 children = new StackBoxInfo[2]; 1332 children[0] = StackBoxInfo.CREATOR.createFromParcel(source); 1333 children[1] = StackBoxInfo.CREATOR.createFromParcel(source); 1334 } else { 1335 stack = StackInfo.CREATOR.createFromParcel(source); 1336 } 1337 } 1338 1339 public static final Creator<StackBoxInfo> CREATOR = 1340 new Creator<ActivityManager.StackBoxInfo>() { 1341 1342 @Override 1343 public StackBoxInfo createFromParcel(Parcel source) { 1344 return new StackBoxInfo(source); 1345 } 1346 1347 @Override 1348 public StackBoxInfo[] newArray(int size) { 1349 return new StackBoxInfo[size]; 1350 } 1351 }; 1352 StackBoxInfo()1353 public StackBoxInfo() { 1354 } 1355 StackBoxInfo(Parcel source)1356 public StackBoxInfo(Parcel source) { 1357 readFromParcel(source); 1358 } 1359 toString(String prefix)1360 public String toString(String prefix) { 1361 StringBuilder sb = new StringBuilder(256); 1362 sb.append(prefix); sb.append("Box id=" + stackBoxId); sb.append(" weight=" + weight); 1363 sb.append(" vertical=" + vertical); sb.append(" bounds=" + bounds.toShortString()); 1364 sb.append("\n"); 1365 if (children != null) { 1366 sb.append(prefix); sb.append("First child=\n"); 1367 sb.append(children[0].toString(prefix + " ")); 1368 sb.append(prefix); sb.append("Second child=\n"); 1369 sb.append(children[1].toString(prefix + " ")); 1370 } else { 1371 sb.append(prefix); sb.append("Stack=\n"); 1372 sb.append(stack.toString(prefix + " ")); 1373 } 1374 return sb.toString(); 1375 } 1376 1377 @Override toString()1378 public String toString() { 1379 return toString(""); 1380 } 1381 } 1382 1383 /** 1384 * Information you can retrieve about an ActivityStack in the system. 1385 * @hide 1386 */ 1387 public static class StackInfo implements Parcelable { 1388 public int stackId; 1389 public Rect bounds; 1390 public int[] taskIds; 1391 public String[] taskNames; 1392 1393 @Override describeContents()1394 public int describeContents() { 1395 return 0; 1396 } 1397 1398 @Override writeToParcel(Parcel dest, int flags)1399 public void writeToParcel(Parcel dest, int flags) { 1400 dest.writeInt(stackId); 1401 dest.writeInt(bounds.left); 1402 dest.writeInt(bounds.top); 1403 dest.writeInt(bounds.right); 1404 dest.writeInt(bounds.bottom); 1405 dest.writeIntArray(taskIds); 1406 dest.writeStringArray(taskNames); 1407 } 1408 readFromParcel(Parcel source)1409 public void readFromParcel(Parcel source) { 1410 stackId = source.readInt(); 1411 bounds = new Rect( 1412 source.readInt(), source.readInt(), source.readInt(), source.readInt()); 1413 taskIds = source.createIntArray(); 1414 taskNames = source.createStringArray(); 1415 } 1416 1417 public static final Creator<StackInfo> CREATOR = new Creator<StackInfo>() { 1418 @Override 1419 public StackInfo createFromParcel(Parcel source) { 1420 return new StackInfo(source); 1421 } 1422 @Override 1423 public StackInfo[] newArray(int size) { 1424 return new StackInfo[size]; 1425 } 1426 }; 1427 StackInfo()1428 public StackInfo() { 1429 } 1430 StackInfo(Parcel source)1431 private StackInfo(Parcel source) { 1432 readFromParcel(source); 1433 } 1434 toString(String prefix)1435 public String toString(String prefix) { 1436 StringBuilder sb = new StringBuilder(256); 1437 sb.append(prefix); sb.append("Stack id="); sb.append(stackId); 1438 sb.append(" bounds="); sb.append(bounds.toShortString()); sb.append("\n"); 1439 prefix = prefix + " "; 1440 for (int i = 0; i < taskIds.length; ++i) { 1441 sb.append(prefix); sb.append("taskId="); sb.append(taskIds[i]); 1442 sb.append(": "); sb.append(taskNames[i]); sb.append("\n"); 1443 } 1444 return sb.toString(); 1445 } 1446 1447 @Override toString()1448 public String toString() { 1449 return toString(""); 1450 } 1451 } 1452 1453 /** 1454 * @hide 1455 */ clearApplicationUserData(String packageName, IPackageDataObserver observer)1456 public boolean clearApplicationUserData(String packageName, IPackageDataObserver observer) { 1457 try { 1458 return ActivityManagerNative.getDefault().clearApplicationUserData(packageName, 1459 observer, UserHandle.myUserId()); 1460 } catch (RemoteException e) { 1461 return false; 1462 } 1463 } 1464 1465 /** 1466 * Permits an application to erase its own data from disk. This is equivalent to 1467 * the user choosing to clear the app's data from within the device settings UI. It 1468 * erases all dynamic data associated with the app -- its private data and data in its 1469 * private area on external storage -- but does not remove the installed application 1470 * itself, nor any OBB files. 1471 * 1472 * @return {@code true} if the application successfully requested that the application's 1473 * data be erased; {@code false} otherwise. 1474 */ clearApplicationUserData()1475 public boolean clearApplicationUserData() { 1476 return clearApplicationUserData(mContext.getPackageName(), null); 1477 } 1478 1479 /** 1480 * Information you can retrieve about any processes that are in an error condition. 1481 */ 1482 public static class ProcessErrorStateInfo implements Parcelable { 1483 /** 1484 * Condition codes 1485 */ 1486 public static final int NO_ERROR = 0; 1487 public static final int CRASHED = 1; 1488 public static final int NOT_RESPONDING = 2; 1489 1490 /** 1491 * The condition that the process is in. 1492 */ 1493 public int condition; 1494 1495 /** 1496 * The process name in which the crash or error occurred. 1497 */ 1498 public String processName; 1499 1500 /** 1501 * The pid of this process; 0 if none 1502 */ 1503 public int pid; 1504 1505 /** 1506 * The kernel user-ID that has been assigned to this process; 1507 * currently this is not a unique ID (multiple applications can have 1508 * the same uid). 1509 */ 1510 public int uid; 1511 1512 /** 1513 * The activity name associated with the error, if known. May be null. 1514 */ 1515 public String tag; 1516 1517 /** 1518 * A short message describing the error condition. 1519 */ 1520 public String shortMsg; 1521 1522 /** 1523 * A long message describing the error condition. 1524 */ 1525 public String longMsg; 1526 1527 /** 1528 * The stack trace where the error originated. May be null. 1529 */ 1530 public String stackTrace; 1531 1532 /** 1533 * to be deprecated: This value will always be null. 1534 */ 1535 public byte[] crashData = null; 1536 ProcessErrorStateInfo()1537 public ProcessErrorStateInfo() { 1538 } 1539 1540 @Override describeContents()1541 public int describeContents() { 1542 return 0; 1543 } 1544 1545 @Override writeToParcel(Parcel dest, int flags)1546 public void writeToParcel(Parcel dest, int flags) { 1547 dest.writeInt(condition); 1548 dest.writeString(processName); 1549 dest.writeInt(pid); 1550 dest.writeInt(uid); 1551 dest.writeString(tag); 1552 dest.writeString(shortMsg); 1553 dest.writeString(longMsg); 1554 dest.writeString(stackTrace); 1555 } 1556 readFromParcel(Parcel source)1557 public void readFromParcel(Parcel source) { 1558 condition = source.readInt(); 1559 processName = source.readString(); 1560 pid = source.readInt(); 1561 uid = source.readInt(); 1562 tag = source.readString(); 1563 shortMsg = source.readString(); 1564 longMsg = source.readString(); 1565 stackTrace = source.readString(); 1566 } 1567 1568 public static final Creator<ProcessErrorStateInfo> CREATOR = 1569 new Creator<ProcessErrorStateInfo>() { 1570 public ProcessErrorStateInfo createFromParcel(Parcel source) { 1571 return new ProcessErrorStateInfo(source); 1572 } 1573 public ProcessErrorStateInfo[] newArray(int size) { 1574 return new ProcessErrorStateInfo[size]; 1575 } 1576 }; 1577 ProcessErrorStateInfo(Parcel source)1578 private ProcessErrorStateInfo(Parcel source) { 1579 readFromParcel(source); 1580 } 1581 } 1582 1583 /** 1584 * Returns a list of any processes that are currently in an error condition. The result 1585 * will be null if all processes are running properly at this time. 1586 * 1587 * @return Returns a list of ProcessErrorStateInfo records, or null if there are no 1588 * current error conditions (it will not return an empty list). This list ordering is not 1589 * specified. 1590 */ getProcessesInErrorState()1591 public List<ProcessErrorStateInfo> getProcessesInErrorState() { 1592 try { 1593 return ActivityManagerNative.getDefault().getProcessesInErrorState(); 1594 } catch (RemoteException e) { 1595 return null; 1596 } 1597 } 1598 1599 /** 1600 * Information you can retrieve about a running process. 1601 */ 1602 public static class RunningAppProcessInfo implements Parcelable { 1603 /** 1604 * The name of the process that this object is associated with 1605 */ 1606 public String processName; 1607 1608 /** 1609 * The pid of this process; 0 if none 1610 */ 1611 public int pid; 1612 1613 /** 1614 * The user id of this process. 1615 */ 1616 public int uid; 1617 1618 /** 1619 * All packages that have been loaded into the process. 1620 */ 1621 public String pkgList[]; 1622 1623 /** 1624 * Constant for {@link #flags}: this is an app that is unable to 1625 * correctly save its state when going to the background, 1626 * so it can not be killed while in the background. 1627 * @hide 1628 */ 1629 public static final int FLAG_CANT_SAVE_STATE = 1<<0; 1630 1631 /** 1632 * Constant for {@link #flags}: this process is associated with a 1633 * persistent system app. 1634 * @hide 1635 */ 1636 public static final int FLAG_PERSISTENT = 1<<1; 1637 1638 /** 1639 * Constant for {@link #flags}: this process is associated with a 1640 * persistent system app. 1641 * @hide 1642 */ 1643 public static final int FLAG_HAS_ACTIVITIES = 1<<2; 1644 1645 /** 1646 * Flags of information. May be any of 1647 * {@link #FLAG_CANT_SAVE_STATE}. 1648 * @hide 1649 */ 1650 public int flags; 1651 1652 /** 1653 * Last memory trim level reported to the process: corresponds to 1654 * the values supplied to {@link android.content.ComponentCallbacks2#onTrimMemory(int) 1655 * ComponentCallbacks2.onTrimMemory(int)}. 1656 */ 1657 public int lastTrimLevel; 1658 1659 /** 1660 * Constant for {@link #importance}: this is a persistent process. 1661 * Only used when reporting to process observers. 1662 * @hide 1663 */ 1664 public static final int IMPORTANCE_PERSISTENT = 50; 1665 1666 /** 1667 * Constant for {@link #importance}: this process is running the 1668 * foreground UI. 1669 */ 1670 public static final int IMPORTANCE_FOREGROUND = 100; 1671 1672 /** 1673 * Constant for {@link #importance}: this process is running something 1674 * that is actively visible to the user, though not in the immediate 1675 * foreground. 1676 */ 1677 public static final int IMPORTANCE_VISIBLE = 200; 1678 1679 /** 1680 * Constant for {@link #importance}: this process is running something 1681 * that is considered to be actively perceptible to the user. An 1682 * example would be an application performing background music playback. 1683 */ 1684 public static final int IMPORTANCE_PERCEPTIBLE = 130; 1685 1686 /** 1687 * Constant for {@link #importance}: this process is running an 1688 * application that can not save its state, and thus can't be killed 1689 * while in the background. 1690 * @hide 1691 */ 1692 public static final int IMPORTANCE_CANT_SAVE_STATE = 170; 1693 1694 /** 1695 * Constant for {@link #importance}: this process is contains services 1696 * that should remain running. 1697 */ 1698 public static final int IMPORTANCE_SERVICE = 300; 1699 1700 /** 1701 * Constant for {@link #importance}: this process process contains 1702 * background code that is expendable. 1703 */ 1704 public static final int IMPORTANCE_BACKGROUND = 400; 1705 1706 /** 1707 * Constant for {@link #importance}: this process is empty of any 1708 * actively running code. 1709 */ 1710 public static final int IMPORTANCE_EMPTY = 500; 1711 1712 /** 1713 * The relative importance level that the system places on this 1714 * process. May be one of {@link #IMPORTANCE_FOREGROUND}, 1715 * {@link #IMPORTANCE_VISIBLE}, {@link #IMPORTANCE_SERVICE}, 1716 * {@link #IMPORTANCE_BACKGROUND}, or {@link #IMPORTANCE_EMPTY}. These 1717 * constants are numbered so that "more important" values are always 1718 * smaller than "less important" values. 1719 */ 1720 public int importance; 1721 1722 /** 1723 * An additional ordering within a particular {@link #importance} 1724 * category, providing finer-grained information about the relative 1725 * utility of processes within a category. This number means nothing 1726 * except that a smaller values are more recently used (and thus 1727 * more important). Currently an LRU value is only maintained for 1728 * the {@link #IMPORTANCE_BACKGROUND} category, though others may 1729 * be maintained in the future. 1730 */ 1731 public int lru; 1732 1733 /** 1734 * Constant for {@link #importanceReasonCode}: nothing special has 1735 * been specified for the reason for this level. 1736 */ 1737 public static final int REASON_UNKNOWN = 0; 1738 1739 /** 1740 * Constant for {@link #importanceReasonCode}: one of the application's 1741 * content providers is being used by another process. The pid of 1742 * the client process is in {@link #importanceReasonPid} and the 1743 * target provider in this process is in 1744 * {@link #importanceReasonComponent}. 1745 */ 1746 public static final int REASON_PROVIDER_IN_USE = 1; 1747 1748 /** 1749 * Constant for {@link #importanceReasonCode}: one of the application's 1750 * content providers is being used by another process. The pid of 1751 * the client process is in {@link #importanceReasonPid} and the 1752 * target provider in this process is in 1753 * {@link #importanceReasonComponent}. 1754 */ 1755 public static final int REASON_SERVICE_IN_USE = 2; 1756 1757 /** 1758 * The reason for {@link #importance}, if any. 1759 */ 1760 public int importanceReasonCode; 1761 1762 /** 1763 * For the specified values of {@link #importanceReasonCode}, this 1764 * is the process ID of the other process that is a client of this 1765 * process. This will be 0 if no other process is using this one. 1766 */ 1767 public int importanceReasonPid; 1768 1769 /** 1770 * For the specified values of {@link #importanceReasonCode}, this 1771 * is the name of the component that is being used in this process. 1772 */ 1773 public ComponentName importanceReasonComponent; 1774 1775 /** 1776 * When {@link #importanceReasonPid} is non-0, this is the importance 1777 * of the other pid. @hide 1778 */ 1779 public int importanceReasonImportance; 1780 RunningAppProcessInfo()1781 public RunningAppProcessInfo() { 1782 importance = IMPORTANCE_FOREGROUND; 1783 importanceReasonCode = REASON_UNKNOWN; 1784 } 1785 RunningAppProcessInfo(String pProcessName, int pPid, String pArr[])1786 public RunningAppProcessInfo(String pProcessName, int pPid, String pArr[]) { 1787 processName = pProcessName; 1788 pid = pPid; 1789 pkgList = pArr; 1790 } 1791 describeContents()1792 public int describeContents() { 1793 return 0; 1794 } 1795 writeToParcel(Parcel dest, int flags)1796 public void writeToParcel(Parcel dest, int flags) { 1797 dest.writeString(processName); 1798 dest.writeInt(pid); 1799 dest.writeInt(uid); 1800 dest.writeStringArray(pkgList); 1801 dest.writeInt(this.flags); 1802 dest.writeInt(lastTrimLevel); 1803 dest.writeInt(importance); 1804 dest.writeInt(lru); 1805 dest.writeInt(importanceReasonCode); 1806 dest.writeInt(importanceReasonPid); 1807 ComponentName.writeToParcel(importanceReasonComponent, dest); 1808 dest.writeInt(importanceReasonImportance); 1809 } 1810 readFromParcel(Parcel source)1811 public void readFromParcel(Parcel source) { 1812 processName = source.readString(); 1813 pid = source.readInt(); 1814 uid = source.readInt(); 1815 pkgList = source.readStringArray(); 1816 flags = source.readInt(); 1817 lastTrimLevel = source.readInt(); 1818 importance = source.readInt(); 1819 lru = source.readInt(); 1820 importanceReasonCode = source.readInt(); 1821 importanceReasonPid = source.readInt(); 1822 importanceReasonComponent = ComponentName.readFromParcel(source); 1823 importanceReasonImportance = source.readInt(); 1824 } 1825 1826 public static final Creator<RunningAppProcessInfo> CREATOR = 1827 new Creator<RunningAppProcessInfo>() { 1828 public RunningAppProcessInfo createFromParcel(Parcel source) { 1829 return new RunningAppProcessInfo(source); 1830 } 1831 public RunningAppProcessInfo[] newArray(int size) { 1832 return new RunningAppProcessInfo[size]; 1833 } 1834 }; 1835 RunningAppProcessInfo(Parcel source)1836 private RunningAppProcessInfo(Parcel source) { 1837 readFromParcel(source); 1838 } 1839 } 1840 1841 /** 1842 * Returns a list of application processes installed on external media 1843 * that are running on the device. 1844 * 1845 * <p><b>Note: this method is only intended for debugging or building 1846 * a user-facing process management UI.</b></p> 1847 * 1848 * @return Returns a list of ApplicationInfo records, or null if none 1849 * This list ordering is not specified. 1850 * @hide 1851 */ getRunningExternalApplications()1852 public List<ApplicationInfo> getRunningExternalApplications() { 1853 try { 1854 return ActivityManagerNative.getDefault().getRunningExternalApplications(); 1855 } catch (RemoteException e) { 1856 return null; 1857 } 1858 } 1859 1860 /** 1861 * Returns a list of application processes that are running on the device. 1862 * 1863 * <p><b>Note: this method is only intended for debugging or building 1864 * a user-facing process management UI.</b></p> 1865 * 1866 * @return Returns a list of RunningAppProcessInfo records, or null if there are no 1867 * running processes (it will not return an empty list). This list ordering is not 1868 * specified. 1869 */ getRunningAppProcesses()1870 public List<RunningAppProcessInfo> getRunningAppProcesses() { 1871 try { 1872 return ActivityManagerNative.getDefault().getRunningAppProcesses(); 1873 } catch (RemoteException e) { 1874 return null; 1875 } 1876 } 1877 1878 /** 1879 * Return global memory state information for the calling process. This 1880 * does not fill in all fields of the {@link RunningAppProcessInfo}. The 1881 * only fields that will be filled in are 1882 * {@link RunningAppProcessInfo#pid}, 1883 * {@link RunningAppProcessInfo#uid}, 1884 * {@link RunningAppProcessInfo#lastTrimLevel}, 1885 * {@link RunningAppProcessInfo#importance}, 1886 * {@link RunningAppProcessInfo#lru}, and 1887 * {@link RunningAppProcessInfo#importanceReasonCode}. 1888 */ getMyMemoryState(RunningAppProcessInfo outState)1889 static public void getMyMemoryState(RunningAppProcessInfo outState) { 1890 try { 1891 ActivityManagerNative.getDefault().getMyMemoryState(outState); 1892 } catch (RemoteException e) { 1893 } 1894 } 1895 1896 /** 1897 * Return information about the memory usage of one or more processes. 1898 * 1899 * <p><b>Note: this method is only intended for debugging or building 1900 * a user-facing process management UI.</b></p> 1901 * 1902 * @param pids The pids of the processes whose memory usage is to be 1903 * retrieved. 1904 * @return Returns an array of memory information, one for each 1905 * requested pid. 1906 */ getProcessMemoryInfo(int[] pids)1907 public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids) { 1908 try { 1909 return ActivityManagerNative.getDefault().getProcessMemoryInfo(pids); 1910 } catch (RemoteException e) { 1911 return null; 1912 } 1913 } 1914 1915 /** 1916 * @deprecated This is now just a wrapper for 1917 * {@link #killBackgroundProcesses(String)}; the previous behavior here 1918 * is no longer available to applications because it allows them to 1919 * break other applications by removing their alarms, stopping their 1920 * services, etc. 1921 */ 1922 @Deprecated restartPackage(String packageName)1923 public void restartPackage(String packageName) { 1924 killBackgroundProcesses(packageName); 1925 } 1926 1927 /** 1928 * Have the system immediately kill all background processes associated 1929 * with the given package. This is the same as the kernel killing those 1930 * processes to reclaim memory; the system will take care of restarting 1931 * these processes in the future as needed. 1932 * 1933 * <p>You must hold the permission 1934 * {@link android.Manifest.permission#KILL_BACKGROUND_PROCESSES} to be able to 1935 * call this method. 1936 * 1937 * @param packageName The name of the package whose processes are to 1938 * be killed. 1939 */ killBackgroundProcesses(String packageName)1940 public void killBackgroundProcesses(String packageName) { 1941 try { 1942 ActivityManagerNative.getDefault().killBackgroundProcesses(packageName, 1943 UserHandle.myUserId()); 1944 } catch (RemoteException e) { 1945 } 1946 } 1947 1948 /** 1949 * Have the system perform a force stop of everything associated with 1950 * the given application package. All processes that share its uid 1951 * will be killed, all services it has running stopped, all activities 1952 * removed, etc. In addition, a {@link Intent#ACTION_PACKAGE_RESTARTED} 1953 * broadcast will be sent, so that any of its registered alarms can 1954 * be stopped, notifications removed, etc. 1955 * 1956 * <p>You must hold the permission 1957 * {@link android.Manifest.permission#FORCE_STOP_PACKAGES} to be able to 1958 * call this method. 1959 * 1960 * @param packageName The name of the package to be stopped. 1961 * 1962 * @hide This is not available to third party applications due to 1963 * it allowing them to break other applications by stopping their 1964 * services, removing their alarms, etc. 1965 */ forceStopPackage(String packageName)1966 public void forceStopPackage(String packageName) { 1967 try { 1968 ActivityManagerNative.getDefault().forceStopPackage(packageName, 1969 UserHandle.myUserId()); 1970 } catch (RemoteException e) { 1971 } 1972 } 1973 1974 /** 1975 * Get the device configuration attributes. 1976 */ getDeviceConfigurationInfo()1977 public ConfigurationInfo getDeviceConfigurationInfo() { 1978 try { 1979 return ActivityManagerNative.getDefault().getDeviceConfigurationInfo(); 1980 } catch (RemoteException e) { 1981 } 1982 return null; 1983 } 1984 1985 /** 1986 * Get the preferred density of icons for the launcher. This is used when 1987 * custom drawables are created (e.g., for shortcuts). 1988 * 1989 * @return density in terms of DPI 1990 */ getLauncherLargeIconDensity()1991 public int getLauncherLargeIconDensity() { 1992 final Resources res = mContext.getResources(); 1993 final int density = res.getDisplayMetrics().densityDpi; 1994 final int sw = res.getConfiguration().smallestScreenWidthDp; 1995 1996 if (sw < 600) { 1997 // Smaller than approx 7" tablets, use the regular icon size. 1998 return density; 1999 } 2000 2001 switch (density) { 2002 case DisplayMetrics.DENSITY_LOW: 2003 return DisplayMetrics.DENSITY_MEDIUM; 2004 case DisplayMetrics.DENSITY_MEDIUM: 2005 return DisplayMetrics.DENSITY_HIGH; 2006 case DisplayMetrics.DENSITY_TV: 2007 return DisplayMetrics.DENSITY_XHIGH; 2008 case DisplayMetrics.DENSITY_HIGH: 2009 return DisplayMetrics.DENSITY_XHIGH; 2010 case DisplayMetrics.DENSITY_XHIGH: 2011 return DisplayMetrics.DENSITY_XXHIGH; 2012 case DisplayMetrics.DENSITY_XXHIGH: 2013 return DisplayMetrics.DENSITY_XHIGH * 2; 2014 default: 2015 // The density is some abnormal value. Return some other 2016 // abnormal value that is a reasonable scaling of it. 2017 return (int)((density*1.5f)+.5f); 2018 } 2019 } 2020 2021 /** 2022 * Get the preferred launcher icon size. This is used when custom drawables 2023 * are created (e.g., for shortcuts). 2024 * 2025 * @return dimensions of square icons in terms of pixels 2026 */ getLauncherLargeIconSize()2027 public int getLauncherLargeIconSize() { 2028 final Resources res = mContext.getResources(); 2029 final int size = res.getDimensionPixelSize(android.R.dimen.app_icon_size); 2030 final int sw = res.getConfiguration().smallestScreenWidthDp; 2031 2032 if (sw < 600) { 2033 // Smaller than approx 7" tablets, use the regular icon size. 2034 return size; 2035 } 2036 2037 final int density = res.getDisplayMetrics().densityDpi; 2038 2039 switch (density) { 2040 case DisplayMetrics.DENSITY_LOW: 2041 return (size * DisplayMetrics.DENSITY_MEDIUM) / DisplayMetrics.DENSITY_LOW; 2042 case DisplayMetrics.DENSITY_MEDIUM: 2043 return (size * DisplayMetrics.DENSITY_HIGH) / DisplayMetrics.DENSITY_MEDIUM; 2044 case DisplayMetrics.DENSITY_TV: 2045 return (size * DisplayMetrics.DENSITY_XHIGH) / DisplayMetrics.DENSITY_HIGH; 2046 case DisplayMetrics.DENSITY_HIGH: 2047 return (size * DisplayMetrics.DENSITY_XHIGH) / DisplayMetrics.DENSITY_HIGH; 2048 case DisplayMetrics.DENSITY_XHIGH: 2049 return (size * DisplayMetrics.DENSITY_XXHIGH) / DisplayMetrics.DENSITY_XHIGH; 2050 case DisplayMetrics.DENSITY_XXHIGH: 2051 return (size * DisplayMetrics.DENSITY_XHIGH*2) / DisplayMetrics.DENSITY_XXHIGH; 2052 default: 2053 // The density is some abnormal value. Return some other 2054 // abnormal value that is a reasonable scaling of it. 2055 return (int)((size*1.5f) + .5f); 2056 } 2057 } 2058 2059 /** 2060 * Returns "true" if the user interface is currently being messed with 2061 * by a monkey. 2062 */ isUserAMonkey()2063 public static boolean isUserAMonkey() { 2064 try { 2065 return ActivityManagerNative.getDefault().isUserAMonkey(); 2066 } catch (RemoteException e) { 2067 } 2068 return false; 2069 } 2070 2071 /** 2072 * Returns "true" if device is running in a test harness. 2073 */ isRunningInTestHarness()2074 public static boolean isRunningInTestHarness() { 2075 return SystemProperties.getBoolean("ro.test_harness", false); 2076 } 2077 2078 /** 2079 * Returns the launch count of each installed package. 2080 * 2081 * @hide 2082 */ getAllPackageLaunchCounts()2083 public Map<String, Integer> getAllPackageLaunchCounts() { 2084 try { 2085 IUsageStats usageStatsService = IUsageStats.Stub.asInterface( 2086 ServiceManager.getService("usagestats")); 2087 if (usageStatsService == null) { 2088 return new HashMap<String, Integer>(); 2089 } 2090 2091 PkgUsageStats[] allPkgUsageStats = usageStatsService.getAllPkgUsageStats(); 2092 if (allPkgUsageStats == null) { 2093 return new HashMap<String, Integer>(); 2094 } 2095 2096 Map<String, Integer> launchCounts = new HashMap<String, Integer>(); 2097 for (PkgUsageStats pkgUsageStats : allPkgUsageStats) { 2098 launchCounts.put(pkgUsageStats.packageName, pkgUsageStats.launchCount); 2099 } 2100 2101 return launchCounts; 2102 } catch (RemoteException e) { 2103 Log.w(TAG, "Could not query launch counts", e); 2104 return new HashMap<String, Integer>(); 2105 } 2106 } 2107 2108 /** @hide */ checkComponentPermission(String permission, int uid, int owningUid, boolean exported)2109 public static int checkComponentPermission(String permission, int uid, 2110 int owningUid, boolean exported) { 2111 // Root, system server get to do everything. 2112 if (uid == 0 || uid == Process.SYSTEM_UID) { 2113 return PackageManager.PERMISSION_GRANTED; 2114 } 2115 // Isolated processes don't get any permissions. 2116 if (UserHandle.isIsolated(uid)) { 2117 return PackageManager.PERMISSION_DENIED; 2118 } 2119 // If there is a uid that owns whatever is being accessed, it has 2120 // blanket access to it regardless of the permissions it requires. 2121 if (owningUid >= 0 && UserHandle.isSameApp(uid, owningUid)) { 2122 return PackageManager.PERMISSION_GRANTED; 2123 } 2124 // If the target is not exported, then nobody else can get to it. 2125 if (!exported) { 2126 /* 2127 RuntimeException here = new RuntimeException("here"); 2128 here.fillInStackTrace(); 2129 Slog.w(TAG, "Permission denied: checkComponentPermission() owningUid=" + owningUid, 2130 here); 2131 */ 2132 return PackageManager.PERMISSION_DENIED; 2133 } 2134 if (permission == null) { 2135 return PackageManager.PERMISSION_GRANTED; 2136 } 2137 try { 2138 return AppGlobals.getPackageManager() 2139 .checkUidPermission(permission, uid); 2140 } catch (RemoteException e) { 2141 // Should never happen, but if it does... deny! 2142 Slog.e(TAG, "PackageManager is dead?!?", e); 2143 } 2144 return PackageManager.PERMISSION_DENIED; 2145 } 2146 2147 /** @hide */ checkUidPermission(String permission, int uid)2148 public static int checkUidPermission(String permission, int uid) { 2149 try { 2150 return AppGlobals.getPackageManager() 2151 .checkUidPermission(permission, uid); 2152 } catch (RemoteException e) { 2153 // Should never happen, but if it does... deny! 2154 Slog.e(TAG, "PackageManager is dead?!?", e); 2155 } 2156 return PackageManager.PERMISSION_DENIED; 2157 } 2158 2159 /** 2160 * @hide 2161 * Helper for dealing with incoming user arguments to system service calls. 2162 * Takes care of checking permissions and converting USER_CURRENT to the 2163 * actual current user. 2164 * 2165 * @param callingPid The pid of the incoming call, as per Binder.getCallingPid(). 2166 * @param callingUid The uid of the incoming call, as per Binder.getCallingUid(). 2167 * @param userId The user id argument supplied by the caller -- this is the user 2168 * they want to run as. 2169 * @param allowAll If true, we will allow USER_ALL. This means you must be prepared 2170 * to get a USER_ALL returned and deal with it correctly. If false, 2171 * an exception will be thrown if USER_ALL is supplied. 2172 * @param requireFull If true, the caller must hold 2173 * {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL} to be able to run as a 2174 * different user than their current process; otherwise they must hold 2175 * {@link android.Manifest.permission#INTERACT_ACROSS_USERS}. 2176 * @param name Optional textual name of the incoming call; only for generating error messages. 2177 * @param callerPackage Optional package name of caller; only for error messages. 2178 * 2179 * @return Returns the user ID that the call should run as. Will always be a concrete 2180 * user number, unless <var>allowAll</var> is true in which case it could also be 2181 * USER_ALL. 2182 */ handleIncomingUser(int callingPid, int callingUid, int userId, boolean allowAll, boolean requireFull, String name, String callerPackage)2183 public static int handleIncomingUser(int callingPid, int callingUid, int userId, 2184 boolean allowAll, boolean requireFull, String name, String callerPackage) { 2185 if (UserHandle.getUserId(callingUid) == userId) { 2186 return userId; 2187 } 2188 try { 2189 return ActivityManagerNative.getDefault().handleIncomingUser(callingPid, 2190 callingUid, userId, allowAll, requireFull, name, callerPackage); 2191 } catch (RemoteException e) { 2192 throw new SecurityException("Failed calling activity manager", e); 2193 } 2194 } 2195 2196 /** @hide */ getCurrentUser()2197 public static int getCurrentUser() { 2198 UserInfo ui; 2199 try { 2200 ui = ActivityManagerNative.getDefault().getCurrentUser(); 2201 return ui != null ? ui.id : 0; 2202 } catch (RemoteException e) { 2203 return 0; 2204 } 2205 } 2206 2207 /** 2208 * Returns the usage statistics of each installed package. 2209 * 2210 * @hide 2211 */ getAllPackageUsageStats()2212 public PkgUsageStats[] getAllPackageUsageStats() { 2213 try { 2214 IUsageStats usageStatsService = IUsageStats.Stub.asInterface( 2215 ServiceManager.getService("usagestats")); 2216 if (usageStatsService != null) { 2217 return usageStatsService.getAllPkgUsageStats(); 2218 } 2219 } catch (RemoteException e) { 2220 Log.w(TAG, "Could not query usage stats", e); 2221 } 2222 return new PkgUsageStats[0]; 2223 } 2224 2225 /** 2226 * @param userid the user's id. Zero indicates the default user 2227 * @hide 2228 */ switchUser(int userid)2229 public boolean switchUser(int userid) { 2230 try { 2231 return ActivityManagerNative.getDefault().switchUser(userid); 2232 } catch (RemoteException e) { 2233 return false; 2234 } 2235 } 2236 2237 /** 2238 * Return whether the given user is actively running. This means that 2239 * the user is in the "started" state, not "stopped" -- it is currently 2240 * allowed to run code through scheduled alarms, receiving broadcasts, 2241 * etc. A started user may be either the current foreground user or a 2242 * background user; the result here does not distinguish between the two. 2243 * @param userid the user's id. Zero indicates the default user. 2244 * @hide 2245 */ isUserRunning(int userid)2246 public boolean isUserRunning(int userid) { 2247 try { 2248 return ActivityManagerNative.getDefault().isUserRunning(userid, false); 2249 } catch (RemoteException e) { 2250 return false; 2251 } 2252 } 2253 2254 /** 2255 * Perform a system dump of various state associated with the given application 2256 * package name. This call blocks while the dump is being performed, so should 2257 * not be done on a UI thread. The data will be written to the given file 2258 * descriptor as text. An application must hold the 2259 * {@link android.Manifest.permission#DUMP} permission to make this call. 2260 * @param fd The file descriptor that the dump should be written to. The file 2261 * descriptor is <em>not</em> closed by this function; the caller continues to 2262 * own it. 2263 * @param packageName The name of the package that is to be dumped. 2264 */ dumpPackageState(FileDescriptor fd, String packageName)2265 public void dumpPackageState(FileDescriptor fd, String packageName) { 2266 dumpPackageStateStatic(fd, packageName); 2267 } 2268 2269 /** 2270 * @hide 2271 */ dumpPackageStateStatic(FileDescriptor fd, String packageName)2272 public static void dumpPackageStateStatic(FileDescriptor fd, String packageName) { 2273 FileOutputStream fout = new FileOutputStream(fd); 2274 PrintWriter pw = new FastPrintWriter(fout); 2275 dumpService(pw, fd, Context.ACTIVITY_SERVICE, new String[] { 2276 "-a", "package", packageName }); 2277 pw.println(); 2278 dumpService(pw, fd, "meminfo", new String[] { "--local", packageName }); 2279 pw.println(); 2280 dumpService(pw, fd, ProcessStats.SERVICE_NAME, new String[] { "-a", packageName }); 2281 pw.println(); 2282 dumpService(pw, fd, "usagestats", new String[] { "--packages", packageName }); 2283 pw.println(); 2284 dumpService(pw, fd, "package", new String[] { packageName }); 2285 pw.println(); 2286 dumpService(pw, fd, BatteryStats.SERVICE_NAME, new String[] { packageName }); 2287 pw.flush(); 2288 } 2289 dumpService(PrintWriter pw, FileDescriptor fd, String name, String[] args)2290 private static void dumpService(PrintWriter pw, FileDescriptor fd, String name, String[] args) { 2291 pw.print("DUMP OF SERVICE "); pw.print(name); pw.println(":"); 2292 IBinder service = ServiceManager.checkService(name); 2293 if (service == null) { 2294 pw.println(" (Service not found)"); 2295 return; 2296 } 2297 TransferPipe tp = null; 2298 try { 2299 pw.flush(); 2300 tp = new TransferPipe(); 2301 tp.setBufferPrefix(" "); 2302 service.dumpAsync(tp.getWriteFd().getFileDescriptor(), args); 2303 tp.go(fd); 2304 } catch (Throwable e) { 2305 if (tp != null) { 2306 tp.kill(); 2307 } 2308 pw.println("Failure dumping service:"); 2309 e.printStackTrace(pw); 2310 } 2311 } 2312 } 2313