ActivityManager.java revision 49d228b3f31789f4aed361b526b7edb619a542e9
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 17package android.app; 18 19import com.android.internal.app.IUsageStats; 20import com.android.internal.os.PkgUsageStats; 21import com.android.internal.util.MemInfoReader; 22 23import android.content.ComponentName; 24import android.content.Context; 25import android.content.Intent; 26import android.content.pm.ApplicationInfo; 27import android.content.pm.ConfigurationInfo; 28import android.content.pm.IPackageDataObserver; 29import android.content.res.Configuration; 30import android.content.res.Resources; 31import android.graphics.Bitmap; 32import android.graphics.Point; 33import android.os.Debug; 34import android.os.Handler; 35import android.os.Parcel; 36import android.os.Parcelable; 37import android.os.RemoteException; 38import android.os.ServiceManager; 39import android.os.SystemProperties; 40import android.text.TextUtils; 41import android.util.DisplayMetrics; 42import android.util.Log; 43import android.util.Slog; 44import android.view.Display; 45 46import java.util.ArrayList; 47import java.util.HashMap; 48import java.util.List; 49import java.util.Map; 50 51/** 52 * Interact with the overall activities running in the system. 53 */ 54public class ActivityManager { 55 private static String TAG = "ActivityManager"; 56 private static boolean localLOGV = false; 57 58 private final Context mContext; 59 private final Handler mHandler; 60 61 /*package*/ ActivityManager(Context context, Handler handler) { 62 mContext = context; 63 mHandler = handler; 64 } 65 66 /** 67 * Screen compatibility mode: the application most always run in 68 * compatibility mode. 69 * @hide 70 */ 71 public static final int COMPAT_MODE_ALWAYS = -1; 72 73 /** 74 * Screen compatibility mode: the application can never run in 75 * compatibility mode. 76 * @hide 77 */ 78 public static final int COMPAT_MODE_NEVER = -2; 79 80 /** 81 * Screen compatibility mode: unknown. 82 * @hide 83 */ 84 public static final int COMPAT_MODE_UNKNOWN = -3; 85 86 /** 87 * Screen compatibility mode: the application currently has compatibility 88 * mode disabled. 89 * @hide 90 */ 91 public static final int COMPAT_MODE_DISABLED = 0; 92 93 /** 94 * Screen compatibility mode: the application currently has compatibility 95 * mode enabled. 96 * @hide 97 */ 98 public static final int COMPAT_MODE_ENABLED = 1; 99 100 /** 101 * Screen compatibility mode: request to toggle the application's 102 * compatibility mode. 103 * @hide 104 */ 105 public static final int COMPAT_MODE_TOGGLE = 2; 106 107 /** @hide */ 108 public int getFrontActivityScreenCompatMode() { 109 try { 110 return ActivityManagerNative.getDefault().getFrontActivityScreenCompatMode(); 111 } catch (RemoteException e) { 112 // System dead, we will be dead too soon! 113 return 0; 114 } 115 } 116 117 /** @hide */ 118 public void setFrontActivityScreenCompatMode(int mode) { 119 try { 120 ActivityManagerNative.getDefault().setFrontActivityScreenCompatMode(mode); 121 } catch (RemoteException e) { 122 // System dead, we will be dead too soon! 123 } 124 } 125 126 /** @hide */ 127 public int getPackageScreenCompatMode(String packageName) { 128 try { 129 return ActivityManagerNative.getDefault().getPackageScreenCompatMode(packageName); 130 } catch (RemoteException e) { 131 // System dead, we will be dead too soon! 132 return 0; 133 } 134 } 135 136 /** @hide */ 137 public void setPackageScreenCompatMode(String packageName, int mode) { 138 try { 139 ActivityManagerNative.getDefault().setPackageScreenCompatMode(packageName, mode); 140 } catch (RemoteException e) { 141 // System dead, we will be dead too soon! 142 } 143 } 144 145 /** @hide */ 146 public boolean getPackageAskScreenCompat(String packageName) { 147 try { 148 return ActivityManagerNative.getDefault().getPackageAskScreenCompat(packageName); 149 } catch (RemoteException e) { 150 // System dead, we will be dead too soon! 151 return false; 152 } 153 } 154 155 /** @hide */ 156 public void setPackageAskScreenCompat(String packageName, boolean ask) { 157 try { 158 ActivityManagerNative.getDefault().setPackageAskScreenCompat(packageName, ask); 159 } catch (RemoteException e) { 160 // System dead, we will be dead too soon! 161 } 162 } 163 164 /** 165 * Return the approximate per-application memory class of the current 166 * device. This gives you an idea of how hard a memory limit you should 167 * impose on your application to let the overall system work best. The 168 * returned value is in megabytes; the baseline Android memory class is 169 * 16 (which happens to be the Java heap limit of those devices); some 170 * device with more memory may return 24 or even higher numbers. 171 */ 172 public int getMemoryClass() { 173 return staticGetMemoryClass(); 174 } 175 176 /** @hide */ 177 static public int staticGetMemoryClass() { 178 // Really brain dead right now -- just take this from the configured 179 // vm heap size, and assume it is in megabytes and thus ends with "m". 180 String vmHeapSize = SystemProperties.get("dalvik.vm.heapgrowthlimit", ""); 181 if (vmHeapSize != null && !"".equals(vmHeapSize)) { 182 return Integer.parseInt(vmHeapSize.substring(0, vmHeapSize.length()-1)); 183 } 184 return staticGetLargeMemoryClass(); 185 } 186 187 /** 188 * Return the approximate per-application memory class of the current 189 * device when an application is running with a large heap. This is the 190 * space available for memory-intensive applications; most applications 191 * should not need this amount of memory, and should instead stay with the 192 * {@link #getMemoryClass()} limit. The returned value is in megabytes. 193 * This may be the same size as {@link #getMemoryClass()} on memory 194 * constrained devices, or it may be significantly larger on devices with 195 * a large amount of available RAM. 196 * 197 * <p>The is the size of the application's Dalvik heap if it has 198 * specified <code>android:largeHeap="true"</code> in its manifest. 199 */ 200 public int getLargeMemoryClass() { 201 return staticGetLargeMemoryClass(); 202 } 203 204 /** @hide */ 205 static public int staticGetLargeMemoryClass() { 206 // Really brain dead right now -- just take this from the configured 207 // vm heap size, and assume it is in megabytes and thus ends with "m". 208 String vmHeapSize = SystemProperties.get("dalvik.vm.heapsize", "16m"); 209 return Integer.parseInt(vmHeapSize.substring(0, vmHeapSize.length()-1)); 210 } 211 212 /** 213 * Used by persistent processes to determine if they are running on a 214 * higher-end device so should be okay using hardware drawing acceleration 215 * (which tends to consume a lot more RAM). 216 * @hide 217 */ 218 static public boolean isHighEndGfx(Display display) { 219 MemInfoReader reader = new MemInfoReader(); 220 reader.readMemInfo(); 221 if (reader.getTotalSize() >= (512*1024*1024)) { 222 // If the device has at least 512MB RAM available to the kernel, 223 // we can afford the overhead of graphics acceleration. 224 return true; 225 } 226 Point p = new Point(); 227 display.getRealSize(p); 228 int pixels = p.x * p.y; 229 if (pixels >= (1024*600)) { 230 // If this is a sufficiently large screen, then there are enough 231 // pixels on it that we'd really like to use hw drawing. 232 return true; 233 } 234 return false; 235 } 236 237 /** 238 * Use to decide whether the running device can be considered a "large 239 * RAM" device. Exactly what memory limit large RAM is will vary, but 240 * it essentially means there is plenty of RAM to have lots of background 241 * processes running under decent loads. 242 * @hide 243 */ 244 static public boolean isLargeRAM() { 245 MemInfoReader reader = new MemInfoReader(); 246 reader.readMemInfo(); 247 if (reader.getTotalSize() >= (640*1024*1024)) { 248 // Currently 640MB RAM available to the kernel is the point at 249 // which we have plenty of RAM to spare. 250 return true; 251 } 252 return false; 253 } 254 255 /** 256 * Information you can retrieve about tasks that the user has most recently 257 * started or visited. 258 */ 259 public static class RecentTaskInfo implements Parcelable { 260 /** 261 * If this task is currently running, this is the identifier for it. 262 * If it is not running, this will be -1. 263 */ 264 public int id; 265 266 /** 267 * The true identifier of this task, valid even if it is not running. 268 */ 269 public int persistentId; 270 271 /** 272 * The original Intent used to launch the task. You can use this 273 * Intent to re-launch the task (if it is no longer running) or bring 274 * the current task to the front. 275 */ 276 public Intent baseIntent; 277 278 /** 279 * If this task was started from an alias, this is the actual 280 * activity component that was initially started; the component of 281 * the baseIntent in this case is the name of the actual activity 282 * implementation that the alias referred to. Otherwise, this is null. 283 */ 284 public ComponentName origActivity; 285 286 /** 287 * Description of the task's last state. 288 */ 289 public CharSequence description; 290 291 public RecentTaskInfo() { 292 } 293 294 public int describeContents() { 295 return 0; 296 } 297 298 public void writeToParcel(Parcel dest, int flags) { 299 dest.writeInt(id); 300 dest.writeInt(persistentId); 301 if (baseIntent != null) { 302 dest.writeInt(1); 303 baseIntent.writeToParcel(dest, 0); 304 } else { 305 dest.writeInt(0); 306 } 307 ComponentName.writeToParcel(origActivity, dest); 308 TextUtils.writeToParcel(description, dest, 309 Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 310 } 311 312 public void readFromParcel(Parcel source) { 313 id = source.readInt(); 314 persistentId = source.readInt(); 315 if (source.readInt() != 0) { 316 baseIntent = Intent.CREATOR.createFromParcel(source); 317 } else { 318 baseIntent = null; 319 } 320 origActivity = ComponentName.readFromParcel(source); 321 description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source); 322 } 323 324 public static final Creator<RecentTaskInfo> CREATOR 325 = new Creator<RecentTaskInfo>() { 326 public RecentTaskInfo createFromParcel(Parcel source) { 327 return new RecentTaskInfo(source); 328 } 329 public RecentTaskInfo[] newArray(int size) { 330 return new RecentTaskInfo[size]; 331 } 332 }; 333 334 private RecentTaskInfo(Parcel source) { 335 readFromParcel(source); 336 } 337 } 338 339 /** 340 * Flag for use with {@link #getRecentTasks}: return all tasks, even those 341 * that have set their 342 * {@link android.content.Intent#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS} flag. 343 */ 344 public static final int RECENT_WITH_EXCLUDED = 0x0001; 345 346 /** 347 * Provides a list that does not contain any 348 * recent tasks that currently are not available to the user. 349 */ 350 public static final int RECENT_IGNORE_UNAVAILABLE = 0x0002; 351 352 /** 353 * Return a list of the tasks that the user has recently launched, with 354 * the most recent being first and older ones after in order. 355 * 356 * @param maxNum The maximum number of entries to return in the list. The 357 * actual number returned may be smaller, depending on how many tasks the 358 * user has started and the maximum number the system can remember. 359 * @param flags Information about what to return. May be any combination 360 * of {@link #RECENT_WITH_EXCLUDED} and {@link #RECENT_IGNORE_UNAVAILABLE}. 361 * 362 * @return Returns a list of RecentTaskInfo records describing each of 363 * the recent tasks. 364 * 365 * @throws SecurityException Throws SecurityException if the caller does 366 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 367 */ 368 public List<RecentTaskInfo> getRecentTasks(int maxNum, int flags) 369 throws SecurityException { 370 try { 371 return ActivityManagerNative.getDefault().getRecentTasks(maxNum, 372 flags); 373 } catch (RemoteException e) { 374 // System dead, we will be dead too soon! 375 return null; 376 } 377 } 378 379 /** 380 * Information you can retrieve about a particular task that is currently 381 * "running" in the system. Note that a running task does not mean the 382 * given task actually has a process it is actively running in; it simply 383 * means that the user has gone to it and never closed it, but currently 384 * the system may have killed its process and is only holding on to its 385 * last state in order to restart it when the user returns. 386 */ 387 public static class RunningTaskInfo implements Parcelable { 388 /** 389 * A unique identifier for this task. 390 */ 391 public int id; 392 393 /** 394 * The component launched as the first activity in the task. This can 395 * be considered the "application" of this task. 396 */ 397 public ComponentName baseActivity; 398 399 /** 400 * The activity component at the top of the history stack of the task. 401 * This is what the user is currently doing. 402 */ 403 public ComponentName topActivity; 404 405 /** 406 * Thumbnail representation of the task's current state. Currently 407 * always null. 408 */ 409 public Bitmap thumbnail; 410 411 /** 412 * Description of the task's current state. 413 */ 414 public CharSequence description; 415 416 /** 417 * Number of activities in this task. 418 */ 419 public int numActivities; 420 421 /** 422 * Number of activities that are currently running (not stopped 423 * and persisted) in this task. 424 */ 425 public int numRunning; 426 427 public RunningTaskInfo() { 428 } 429 430 public int describeContents() { 431 return 0; 432 } 433 434 public void writeToParcel(Parcel dest, int flags) { 435 dest.writeInt(id); 436 ComponentName.writeToParcel(baseActivity, dest); 437 ComponentName.writeToParcel(topActivity, dest); 438 if (thumbnail != null) { 439 dest.writeInt(1); 440 thumbnail.writeToParcel(dest, 0); 441 } else { 442 dest.writeInt(0); 443 } 444 TextUtils.writeToParcel(description, dest, 445 Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 446 dest.writeInt(numActivities); 447 dest.writeInt(numRunning); 448 } 449 450 public void readFromParcel(Parcel source) { 451 id = source.readInt(); 452 baseActivity = ComponentName.readFromParcel(source); 453 topActivity = ComponentName.readFromParcel(source); 454 if (source.readInt() != 0) { 455 thumbnail = Bitmap.CREATOR.createFromParcel(source); 456 } else { 457 thumbnail = null; 458 } 459 description = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(source); 460 numActivities = source.readInt(); 461 numRunning = source.readInt(); 462 } 463 464 public static final Creator<RunningTaskInfo> CREATOR = new Creator<RunningTaskInfo>() { 465 public RunningTaskInfo createFromParcel(Parcel source) { 466 return new RunningTaskInfo(source); 467 } 468 public RunningTaskInfo[] newArray(int size) { 469 return new RunningTaskInfo[size]; 470 } 471 }; 472 473 private RunningTaskInfo(Parcel source) { 474 readFromParcel(source); 475 } 476 } 477 478 /** 479 * Return a list of the tasks that are currently running, with 480 * the most recent being first and older ones after in order. Note that 481 * "running" does not mean any of the task's code is currently loaded or 482 * activity -- the task may have been frozen by the system, so that it 483 * can be restarted in its previous state when next brought to the 484 * foreground. 485 * 486 * @param maxNum The maximum number of entries to return in the list. The 487 * actual number returned may be smaller, depending on how many tasks the 488 * user has started. 489 * 490 * @param flags Optional flags 491 * @param receiver Optional receiver for delayed thumbnails 492 * 493 * @return Returns a list of RunningTaskInfo records describing each of 494 * the running tasks. 495 * 496 * Some thumbnails may not be available at the time of this call. The optional 497 * receiver may be used to receive those thumbnails. 498 * 499 * @throws SecurityException Throws SecurityException if the caller does 500 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 501 * 502 * @hide 503 */ 504 public List<RunningTaskInfo> getRunningTasks(int maxNum, int flags, IThumbnailReceiver receiver) 505 throws SecurityException { 506 try { 507 return ActivityManagerNative.getDefault().getTasks(maxNum, flags, receiver); 508 } catch (RemoteException e) { 509 // System dead, we will be dead too soon! 510 return null; 511 } 512 } 513 514 /** 515 * Return a list of the tasks that are currently running, with 516 * the most recent being first and older ones after in order. Note that 517 * "running" does not mean any of the task's code is currently loaded or 518 * activity -- the task may have been frozen by the system, so that it 519 * can be restarted in its previous state when next brought to the 520 * foreground. 521 * 522 * @param maxNum The maximum number of entries to return in the list. The 523 * actual number returned may be smaller, depending on how many tasks the 524 * user has started. 525 * 526 * @return Returns a list of RunningTaskInfo records describing each of 527 * the running tasks. 528 * 529 * @throws SecurityException Throws SecurityException if the caller does 530 * not hold the {@link android.Manifest.permission#GET_TASKS} permission. 531 */ 532 public List<RunningTaskInfo> getRunningTasks(int maxNum) 533 throws SecurityException { 534 return getRunningTasks(maxNum, 0, null); 535 } 536 537 /** 538 * Remove some end of a task's activity stack that is not part of 539 * the main application. The selected activities will be finished, so 540 * they are no longer part of the main task. 541 * 542 * @param taskId The identifier of the task. 543 * @param subTaskIndex The number of the sub-task; this corresponds 544 * to the index of the thumbnail returned by {@link #getTaskThumbnails(int)}. 545 * @return Returns true if the sub-task was found and was removed. 546 * 547 * @hide 548 */ 549 public boolean removeSubTask(int taskId, int subTaskIndex) 550 throws SecurityException { 551 try { 552 return ActivityManagerNative.getDefault().removeSubTask(taskId, subTaskIndex); 553 } catch (RemoteException e) { 554 // System dead, we will be dead too soon! 555 return false; 556 } 557 } 558 559 /** 560 * If set, the process of the root activity of the task will be killed 561 * as part of removing the task. 562 * @hide 563 */ 564 public static final int REMOVE_TASK_KILL_PROCESS = 0x0001; 565 566 /** 567 * Completely remove the given task. 568 * 569 * @param taskId Identifier of the task to be removed. 570 * @param flags Additional operational flags. May be 0 or 571 * {@link #REMOVE_TASK_KILL_PROCESS}. 572 * @return Returns true if the given task was found and removed. 573 * 574 * @hide 575 */ 576 public boolean removeTask(int taskId, int flags) 577 throws SecurityException { 578 try { 579 return ActivityManagerNative.getDefault().removeTask(taskId, flags); 580 } catch (RemoteException e) { 581 // System dead, we will be dead too soon! 582 return false; 583 } 584 } 585 586 /** @hide */ 587 public static class TaskThumbnails implements Parcelable { 588 public Bitmap mainThumbnail; 589 590 public int numSubThumbbails; 591 592 /** @hide */ 593 public IThumbnailRetriever retriever; 594 595 public TaskThumbnails() { 596 } 597 598 public Bitmap getSubThumbnail(int index) { 599 try { 600 return retriever.getThumbnail(index); 601 } catch (RemoteException e) { 602 return null; 603 } 604 } 605 606 public int describeContents() { 607 return 0; 608 } 609 610 public void writeToParcel(Parcel dest, int flags) { 611 if (mainThumbnail != null) { 612 dest.writeInt(1); 613 mainThumbnail.writeToParcel(dest, 0); 614 } else { 615 dest.writeInt(0); 616 } 617 dest.writeInt(numSubThumbbails); 618 dest.writeStrongInterface(retriever); 619 } 620 621 public void readFromParcel(Parcel source) { 622 if (source.readInt() != 0) { 623 mainThumbnail = Bitmap.CREATOR.createFromParcel(source); 624 } else { 625 mainThumbnail = null; 626 } 627 numSubThumbbails = source.readInt(); 628 retriever = IThumbnailRetriever.Stub.asInterface(source.readStrongBinder()); 629 } 630 631 public static final Creator<TaskThumbnails> CREATOR = new Creator<TaskThumbnails>() { 632 public TaskThumbnails createFromParcel(Parcel source) { 633 return new TaskThumbnails(source); 634 } 635 public TaskThumbnails[] newArray(int size) { 636 return new TaskThumbnails[size]; 637 } 638 }; 639 640 private TaskThumbnails(Parcel source) { 641 readFromParcel(source); 642 } 643 } 644 645 /** @hide */ 646 public TaskThumbnails getTaskThumbnails(int id) throws SecurityException { 647 try { 648 return ActivityManagerNative.getDefault().getTaskThumbnails(id); 649 } catch (RemoteException e) { 650 // System dead, we will be dead too soon! 651 return null; 652 } 653 } 654 655 /** 656 * Flag for {@link #moveTaskToFront(int, int)}: also move the "home" 657 * activity along with the task, so it is positioned immediately behind 658 * the task. 659 */ 660 public static final int MOVE_TASK_WITH_HOME = 0x00000001; 661 662 /** 663 * Flag for {@link #moveTaskToFront(int, int)}: don't count this as a 664 * user-instigated action, so the current activity will not receive a 665 * hint that the user is leaving. 666 */ 667 public static final int MOVE_TASK_NO_USER_ACTION = 0x00000002; 668 669 /** 670 * Ask that the task associated with a given task ID be moved to the 671 * front of the stack, so it is now visible to the user. Requires that 672 * the caller hold permission {@link android.Manifest.permission#REORDER_TASKS} 673 * or a SecurityException will be thrown. 674 * 675 * @param taskId The identifier of the task to be moved, as found in 676 * {@link RunningTaskInfo} or {@link RecentTaskInfo}. 677 * @param flags Additional operational flags, 0 or more of 678 * {@link #MOVE_TASK_WITH_HOME}. 679 */ 680 public void moveTaskToFront(int taskId, int flags) { 681 try { 682 ActivityManagerNative.getDefault().moveTaskToFront(taskId, flags); 683 } catch (RemoteException e) { 684 // System dead, we will be dead too soon! 685 } 686 } 687 688 /** 689 * Information you can retrieve about a particular Service that is 690 * currently running in the system. 691 */ 692 public static class RunningServiceInfo implements Parcelable { 693 /** 694 * The service component. 695 */ 696 public ComponentName service; 697 698 /** 699 * If non-zero, this is the process the service is running in. 700 */ 701 public int pid; 702 703 /** 704 * The UID that owns this service. 705 */ 706 public int uid; 707 708 /** 709 * The name of the process this service runs in. 710 */ 711 public String process; 712 713 /** 714 * Set to true if the service has asked to run as a foreground process. 715 */ 716 public boolean foreground; 717 718 /** 719 * The time when the service was first made active, either by someone 720 * starting or binding to it. This 721 * is in units of {@link android.os.SystemClock#elapsedRealtime()}. 722 */ 723 public long activeSince; 724 725 /** 726 * Set to true if this service has been explicitly started. 727 */ 728 public boolean started; 729 730 /** 731 * Number of clients connected to the service. 732 */ 733 public int clientCount; 734 735 /** 736 * Number of times the service's process has crashed while the service 737 * is running. 738 */ 739 public int crashCount; 740 741 /** 742 * The time when there was last activity in the service (either 743 * explicit requests to start it or clients binding to it). This 744 * is in units of {@link android.os.SystemClock#uptimeMillis()}. 745 */ 746 public long lastActivityTime; 747 748 /** 749 * If non-zero, this service is not currently running, but scheduled to 750 * restart at the given time. 751 */ 752 public long restarting; 753 754 /** 755 * Bit for {@link #flags}: set if this service has been 756 * explicitly started. 757 */ 758 public static final int FLAG_STARTED = 1<<0; 759 760 /** 761 * Bit for {@link #flags}: set if the service has asked to 762 * run as a foreground process. 763 */ 764 public static final int FLAG_FOREGROUND = 1<<1; 765 766 /** 767 * Bit for {@link #flags): set if the service is running in a 768 * core system process. 769 */ 770 public static final int FLAG_SYSTEM_PROCESS = 1<<2; 771 772 /** 773 * Bit for {@link #flags): set if the service is running in a 774 * persistent process. 775 */ 776 public static final int FLAG_PERSISTENT_PROCESS = 1<<3; 777 778 /** 779 * Running flags. 780 */ 781 public int flags; 782 783 /** 784 * For special services that are bound to by system code, this is 785 * the package that holds the binding. 786 */ 787 public String clientPackage; 788 789 /** 790 * For special services that are bound to by system code, this is 791 * a string resource providing a user-visible label for who the 792 * client is. 793 */ 794 public int clientLabel; 795 796 public RunningServiceInfo() { 797 } 798 799 public int describeContents() { 800 return 0; 801 } 802 803 public void writeToParcel(Parcel dest, int flags) { 804 ComponentName.writeToParcel(service, dest); 805 dest.writeInt(pid); 806 dest.writeInt(uid); 807 dest.writeString(process); 808 dest.writeInt(foreground ? 1 : 0); 809 dest.writeLong(activeSince); 810 dest.writeInt(started ? 1 : 0); 811 dest.writeInt(clientCount); 812 dest.writeInt(crashCount); 813 dest.writeLong(lastActivityTime); 814 dest.writeLong(restarting); 815 dest.writeInt(this.flags); 816 dest.writeString(clientPackage); 817 dest.writeInt(clientLabel); 818 } 819 820 public void readFromParcel(Parcel source) { 821 service = ComponentName.readFromParcel(source); 822 pid = source.readInt(); 823 uid = source.readInt(); 824 process = source.readString(); 825 foreground = source.readInt() != 0; 826 activeSince = source.readLong(); 827 started = source.readInt() != 0; 828 clientCount = source.readInt(); 829 crashCount = source.readInt(); 830 lastActivityTime = source.readLong(); 831 restarting = source.readLong(); 832 flags = source.readInt(); 833 clientPackage = source.readString(); 834 clientLabel = source.readInt(); 835 } 836 837 public static final Creator<RunningServiceInfo> CREATOR = new Creator<RunningServiceInfo>() { 838 public RunningServiceInfo createFromParcel(Parcel source) { 839 return new RunningServiceInfo(source); 840 } 841 public RunningServiceInfo[] newArray(int size) { 842 return new RunningServiceInfo[size]; 843 } 844 }; 845 846 private RunningServiceInfo(Parcel source) { 847 readFromParcel(source); 848 } 849 } 850 851 /** 852 * Return a list of the services that are currently running. 853 * 854 * @param maxNum The maximum number of entries to return in the list. The 855 * actual number returned may be smaller, depending on how many services 856 * are running. 857 * 858 * @return Returns a list of RunningServiceInfo records describing each of 859 * the running tasks. 860 */ 861 public List<RunningServiceInfo> getRunningServices(int maxNum) 862 throws SecurityException { 863 try { 864 return ActivityManagerNative.getDefault() 865 .getServices(maxNum, 0); 866 } catch (RemoteException e) { 867 // System dead, we will be dead too soon! 868 return null; 869 } 870 } 871 872 /** 873 * Returns a PendingIntent you can start to show a control panel for the 874 * given running service. If the service does not have a control panel, 875 * null is returned. 876 */ 877 public PendingIntent getRunningServiceControlPanel(ComponentName service) 878 throws SecurityException { 879 try { 880 return ActivityManagerNative.getDefault() 881 .getRunningServiceControlPanel(service); 882 } catch (RemoteException e) { 883 // System dead, we will be dead too soon! 884 return null; 885 } 886 } 887 888 /** 889 * Information you can retrieve about the available memory through 890 * {@link ActivityManager#getMemoryInfo}. 891 */ 892 public static class MemoryInfo implements Parcelable { 893 /** 894 * The total available memory on the system. This number should not 895 * be considered absolute: due to the nature of the kernel, a significant 896 * portion of this memory is actually in use and needed for the overall 897 * system to run well. 898 */ 899 public long availMem; 900 901 /** 902 * The threshold of {@link #availMem} at which we consider memory to be 903 * low and start killing background services and other non-extraneous 904 * processes. 905 */ 906 public long threshold; 907 908 /** 909 * Set to true if the system considers itself to currently be in a low 910 * memory situation. 911 */ 912 public boolean lowMemory; 913 914 /** @hide */ 915 public long hiddenAppThreshold; 916 /** @hide */ 917 public long secondaryServerThreshold; 918 /** @hide */ 919 public long visibleAppThreshold; 920 /** @hide */ 921 public long foregroundAppThreshold; 922 923 public MemoryInfo() { 924 } 925 926 public int describeContents() { 927 return 0; 928 } 929 930 public void writeToParcel(Parcel dest, int flags) { 931 dest.writeLong(availMem); 932 dest.writeLong(threshold); 933 dest.writeInt(lowMemory ? 1 : 0); 934 dest.writeLong(hiddenAppThreshold); 935 dest.writeLong(secondaryServerThreshold); 936 dest.writeLong(visibleAppThreshold); 937 dest.writeLong(foregroundAppThreshold); 938 } 939 940 public void readFromParcel(Parcel source) { 941 availMem = source.readLong(); 942 threshold = source.readLong(); 943 lowMemory = source.readInt() != 0; 944 hiddenAppThreshold = source.readLong(); 945 secondaryServerThreshold = source.readLong(); 946 visibleAppThreshold = source.readLong(); 947 foregroundAppThreshold = source.readLong(); 948 } 949 950 public static final Creator<MemoryInfo> CREATOR 951 = new Creator<MemoryInfo>() { 952 public MemoryInfo createFromParcel(Parcel source) { 953 return new MemoryInfo(source); 954 } 955 public MemoryInfo[] newArray(int size) { 956 return new MemoryInfo[size]; 957 } 958 }; 959 960 private MemoryInfo(Parcel source) { 961 readFromParcel(source); 962 } 963 } 964 965 public void getMemoryInfo(MemoryInfo outInfo) { 966 try { 967 ActivityManagerNative.getDefault().getMemoryInfo(outInfo); 968 } catch (RemoteException e) { 969 } 970 } 971 972 /** 973 * @hide 974 */ 975 public boolean clearApplicationUserData(String packageName, IPackageDataObserver observer) { 976 try { 977 return ActivityManagerNative.getDefault().clearApplicationUserData(packageName, 978 observer); 979 } catch (RemoteException e) { 980 return false; 981 } 982 } 983 984 /** 985 * Information you can retrieve about any processes that are in an error condition. 986 */ 987 public static class ProcessErrorStateInfo implements Parcelable { 988 /** 989 * Condition codes 990 */ 991 public static final int NO_ERROR = 0; 992 public static final int CRASHED = 1; 993 public static final int NOT_RESPONDING = 2; 994 995 /** 996 * The condition that the process is in. 997 */ 998 public int condition; 999 1000 /** 1001 * The process name in which the crash or error occurred. 1002 */ 1003 public String processName; 1004 1005 /** 1006 * The pid of this process; 0 if none 1007 */ 1008 public int pid; 1009 1010 /** 1011 * The kernel user-ID that has been assigned to this process; 1012 * currently this is not a unique ID (multiple applications can have 1013 * the same uid). 1014 */ 1015 public int uid; 1016 1017 /** 1018 * The activity name associated with the error, if known. May be null. 1019 */ 1020 public String tag; 1021 1022 /** 1023 * A short message describing the error condition. 1024 */ 1025 public String shortMsg; 1026 1027 /** 1028 * A long message describing the error condition. 1029 */ 1030 public String longMsg; 1031 1032 /** 1033 * The stack trace where the error originated. May be null. 1034 */ 1035 public String stackTrace; 1036 1037 /** 1038 * to be deprecated: This value will always be null. 1039 */ 1040 public byte[] crashData = null; 1041 1042 public ProcessErrorStateInfo() { 1043 } 1044 1045 public int describeContents() { 1046 return 0; 1047 } 1048 1049 public void writeToParcel(Parcel dest, int flags) { 1050 dest.writeInt(condition); 1051 dest.writeString(processName); 1052 dest.writeInt(pid); 1053 dest.writeInt(uid); 1054 dest.writeString(tag); 1055 dest.writeString(shortMsg); 1056 dest.writeString(longMsg); 1057 dest.writeString(stackTrace); 1058 } 1059 1060 public void readFromParcel(Parcel source) { 1061 condition = source.readInt(); 1062 processName = source.readString(); 1063 pid = source.readInt(); 1064 uid = source.readInt(); 1065 tag = source.readString(); 1066 shortMsg = source.readString(); 1067 longMsg = source.readString(); 1068 stackTrace = source.readString(); 1069 } 1070 1071 public static final Creator<ProcessErrorStateInfo> CREATOR = 1072 new Creator<ProcessErrorStateInfo>() { 1073 public ProcessErrorStateInfo createFromParcel(Parcel source) { 1074 return new ProcessErrorStateInfo(source); 1075 } 1076 public ProcessErrorStateInfo[] newArray(int size) { 1077 return new ProcessErrorStateInfo[size]; 1078 } 1079 }; 1080 1081 private ProcessErrorStateInfo(Parcel source) { 1082 readFromParcel(source); 1083 } 1084 } 1085 1086 /** 1087 * Returns a list of any processes that are currently in an error condition. The result 1088 * will be null if all processes are running properly at this time. 1089 * 1090 * @return Returns a list of ProcessErrorStateInfo records, or null if there are no 1091 * current error conditions (it will not return an empty list). This list ordering is not 1092 * specified. 1093 */ 1094 public List<ProcessErrorStateInfo> getProcessesInErrorState() { 1095 try { 1096 return ActivityManagerNative.getDefault().getProcessesInErrorState(); 1097 } catch (RemoteException e) { 1098 return null; 1099 } 1100 } 1101 1102 /** 1103 * Information you can retrieve about a running process. 1104 */ 1105 public static class RunningAppProcessInfo implements Parcelable { 1106 /** 1107 * The name of the process that this object is associated with 1108 */ 1109 public String processName; 1110 1111 /** 1112 * The pid of this process; 0 if none 1113 */ 1114 public int pid; 1115 1116 /** 1117 * The user id of this process. 1118 */ 1119 public int uid; 1120 1121 /** 1122 * All packages that have been loaded into the process. 1123 */ 1124 public String pkgList[]; 1125 1126 /** 1127 * Constant for {@link #flags}: this is an app that is unable to 1128 * correctly save its state when going to the background, 1129 * so it can not be killed while in the background. 1130 * @hide 1131 */ 1132 public static final int FLAG_CANT_SAVE_STATE = 1<<0; 1133 1134 /** 1135 * Constant for {@link #flags}: this process is associated with a 1136 * persistent system app. 1137 * @hide 1138 */ 1139 public static final int FLAG_PERSISTENT = 1<<1; 1140 1141 /** 1142 * Flags of information. May be any of 1143 * {@link #FLAG_CANT_SAVE_STATE}. 1144 * @hide 1145 */ 1146 public int flags; 1147 1148 /** 1149 * Constant for {@link #importance}: this process is running the 1150 * foreground UI. 1151 */ 1152 public static final int IMPORTANCE_FOREGROUND = 100; 1153 1154 /** 1155 * Constant for {@link #importance}: this process is running something 1156 * that is actively visible to the user, though not in the immediate 1157 * foreground. 1158 */ 1159 public static final int IMPORTANCE_VISIBLE = 200; 1160 1161 /** 1162 * Constant for {@link #importance}: this process is running something 1163 * that is considered to be actively perceptible to the user. An 1164 * example would be an application performing background music playback. 1165 */ 1166 public static final int IMPORTANCE_PERCEPTIBLE = 130; 1167 1168 /** 1169 * Constant for {@link #importance}: this process is running an 1170 * application that can not save its state, and thus can't be killed 1171 * while in the background. 1172 * @hide 1173 */ 1174 public static final int IMPORTANCE_CANT_SAVE_STATE = 170; 1175 1176 /** 1177 * Constant for {@link #importance}: this process is contains services 1178 * that should remain running. 1179 */ 1180 public static final int IMPORTANCE_SERVICE = 300; 1181 1182 /** 1183 * Constant for {@link #importance}: this process process contains 1184 * background code that is expendable. 1185 */ 1186 public static final int IMPORTANCE_BACKGROUND = 400; 1187 1188 /** 1189 * Constant for {@link #importance}: this process is empty of any 1190 * actively running code. 1191 */ 1192 public static final int IMPORTANCE_EMPTY = 500; 1193 1194 /** 1195 * The relative importance level that the system places on this 1196 * process. May be one of {@link #IMPORTANCE_FOREGROUND}, 1197 * {@link #IMPORTANCE_VISIBLE}, {@link #IMPORTANCE_SERVICE}, 1198 * {@link #IMPORTANCE_BACKGROUND}, or {@link #IMPORTANCE_EMPTY}. These 1199 * constants are numbered so that "more important" values are always 1200 * smaller than "less important" values. 1201 */ 1202 public int importance; 1203 1204 /** 1205 * An additional ordering within a particular {@link #importance} 1206 * category, providing finer-grained information about the relative 1207 * utility of processes within a category. This number means nothing 1208 * except that a smaller values are more recently used (and thus 1209 * more important). Currently an LRU value is only maintained for 1210 * the {@link #IMPORTANCE_BACKGROUND} category, though others may 1211 * be maintained in the future. 1212 */ 1213 public int lru; 1214 1215 /** 1216 * Constant for {@link #importanceReasonCode}: nothing special has 1217 * been specified for the reason for this level. 1218 */ 1219 public static final int REASON_UNKNOWN = 0; 1220 1221 /** 1222 * Constant for {@link #importanceReasonCode}: one of the application's 1223 * content providers is being used by another process. The pid of 1224 * the client process is in {@link #importanceReasonPid} and the 1225 * target provider in this process is in 1226 * {@link #importanceReasonComponent}. 1227 */ 1228 public static final int REASON_PROVIDER_IN_USE = 1; 1229 1230 /** 1231 * Constant for {@link #importanceReasonCode}: one of the application's 1232 * content providers is being used by another process. The pid of 1233 * the client process is in {@link #importanceReasonPid} and the 1234 * target provider in this process is in 1235 * {@link #importanceReasonComponent}. 1236 */ 1237 public static final int REASON_SERVICE_IN_USE = 2; 1238 1239 /** 1240 * The reason for {@link #importance}, if any. 1241 */ 1242 public int importanceReasonCode; 1243 1244 /** 1245 * For the specified values of {@link #importanceReasonCode}, this 1246 * is the process ID of the other process that is a client of this 1247 * process. This will be 0 if no other process is using this one. 1248 */ 1249 public int importanceReasonPid; 1250 1251 /** 1252 * For the specified values of {@link #importanceReasonCode}, this 1253 * is the name of the component that is being used in this process. 1254 */ 1255 public ComponentName importanceReasonComponent; 1256 1257 public RunningAppProcessInfo() { 1258 importance = IMPORTANCE_FOREGROUND; 1259 importanceReasonCode = REASON_UNKNOWN; 1260 } 1261 1262 public RunningAppProcessInfo(String pProcessName, int pPid, String pArr[]) { 1263 processName = pProcessName; 1264 pid = pPid; 1265 pkgList = pArr; 1266 } 1267 1268 public int describeContents() { 1269 return 0; 1270 } 1271 1272 public void writeToParcel(Parcel dest, int flags) { 1273 dest.writeString(processName); 1274 dest.writeInt(pid); 1275 dest.writeInt(uid); 1276 dest.writeStringArray(pkgList); 1277 dest.writeInt(this.flags); 1278 dest.writeInt(importance); 1279 dest.writeInt(lru); 1280 dest.writeInt(importanceReasonCode); 1281 dest.writeInt(importanceReasonPid); 1282 ComponentName.writeToParcel(importanceReasonComponent, dest); 1283 } 1284 1285 public void readFromParcel(Parcel source) { 1286 processName = source.readString(); 1287 pid = source.readInt(); 1288 uid = source.readInt(); 1289 pkgList = source.readStringArray(); 1290 flags = source.readInt(); 1291 importance = source.readInt(); 1292 lru = source.readInt(); 1293 importanceReasonCode = source.readInt(); 1294 importanceReasonPid = source.readInt(); 1295 importanceReasonComponent = ComponentName.readFromParcel(source); 1296 } 1297 1298 public static final Creator<RunningAppProcessInfo> CREATOR = 1299 new Creator<RunningAppProcessInfo>() { 1300 public RunningAppProcessInfo createFromParcel(Parcel source) { 1301 return new RunningAppProcessInfo(source); 1302 } 1303 public RunningAppProcessInfo[] newArray(int size) { 1304 return new RunningAppProcessInfo[size]; 1305 } 1306 }; 1307 1308 private RunningAppProcessInfo(Parcel source) { 1309 readFromParcel(source); 1310 } 1311 } 1312 1313 /** 1314 * Returns a list of application processes installed on external media 1315 * that are running on the device. 1316 * 1317 * @return Returns a list of ApplicationInfo records, or null if none 1318 * This list ordering is not specified. 1319 * @hide 1320 */ 1321 public List<ApplicationInfo> getRunningExternalApplications() { 1322 try { 1323 return ActivityManagerNative.getDefault().getRunningExternalApplications(); 1324 } catch (RemoteException e) { 1325 return null; 1326 } 1327 } 1328 1329 /** 1330 * Returns a list of application processes that are running on the device. 1331 * 1332 * @return Returns a list of RunningAppProcessInfo records, or null if there are no 1333 * running processes (it will not return an empty list). This list ordering is not 1334 * specified. 1335 */ 1336 public List<RunningAppProcessInfo> getRunningAppProcesses() { 1337 try { 1338 return ActivityManagerNative.getDefault().getRunningAppProcesses(); 1339 } catch (RemoteException e) { 1340 return null; 1341 } 1342 } 1343 1344 /** 1345 * Return information about the memory usage of one or more processes. 1346 * 1347 * @param pids The pids of the processes whose memory usage is to be 1348 * retrieved. 1349 * @return Returns an array of memory information, one for each 1350 * requested pid. 1351 */ 1352 public Debug.MemoryInfo[] getProcessMemoryInfo(int[] pids) { 1353 try { 1354 return ActivityManagerNative.getDefault().getProcessMemoryInfo(pids); 1355 } catch (RemoteException e) { 1356 return null; 1357 } 1358 } 1359 1360 /** 1361 * @deprecated This is now just a wrapper for 1362 * {@link #killBackgroundProcesses(String)}; the previous behavior here 1363 * is no longer available to applications because it allows them to 1364 * break other applications by removing their alarms, stopping their 1365 * services, etc. 1366 */ 1367 @Deprecated 1368 public void restartPackage(String packageName) { 1369 killBackgroundProcesses(packageName); 1370 } 1371 1372 /** 1373 * Have the system immediately kill all background processes associated 1374 * with the given package. This is the same as the kernel killing those 1375 * processes to reclaim memory; the system will take care of restarting 1376 * these processes in the future as needed. 1377 * 1378 * <p>You must hold the permission 1379 * {@link android.Manifest.permission#KILL_BACKGROUND_PROCESSES} to be able to 1380 * call this method. 1381 * 1382 * @param packageName The name of the package whose processes are to 1383 * be killed. 1384 */ 1385 public void killBackgroundProcesses(String packageName) { 1386 try { 1387 ActivityManagerNative.getDefault().killBackgroundProcesses(packageName); 1388 } catch (RemoteException e) { 1389 } 1390 } 1391 1392 /** 1393 * Have the system perform a force stop of everything associated with 1394 * the given application package. All processes that share its uid 1395 * will be killed, all services it has running stopped, all activities 1396 * removed, etc. In addition, a {@link Intent#ACTION_PACKAGE_RESTARTED} 1397 * broadcast will be sent, so that any of its registered alarms can 1398 * be stopped, notifications removed, etc. 1399 * 1400 * <p>You must hold the permission 1401 * {@link android.Manifest.permission#FORCE_STOP_PACKAGES} to be able to 1402 * call this method. 1403 * 1404 * @param packageName The name of the package to be stopped. 1405 * 1406 * @hide This is not available to third party applications due to 1407 * it allowing them to break other applications by stopping their 1408 * services, removing their alarms, etc. 1409 */ 1410 public void forceStopPackage(String packageName) { 1411 try { 1412 ActivityManagerNative.getDefault().forceStopPackage(packageName); 1413 } catch (RemoteException e) { 1414 } 1415 } 1416 1417 /** 1418 * Get the device configuration attributes. 1419 */ 1420 public ConfigurationInfo getDeviceConfigurationInfo() { 1421 try { 1422 return ActivityManagerNative.getDefault().getDeviceConfigurationInfo(); 1423 } catch (RemoteException e) { 1424 } 1425 return null; 1426 } 1427 1428 /** 1429 * Get the preferred density of icons for the launcher. This is used when 1430 * custom drawables are created (e.g., for shortcuts). 1431 * 1432 * @return density in terms of DPI 1433 */ 1434 public int getLauncherLargeIconDensity() { 1435 final Resources res = mContext.getResources(); 1436 final int density = res.getDisplayMetrics().densityDpi; 1437 1438 if ((res.getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) 1439 != Configuration.SCREENLAYOUT_SIZE_XLARGE) { 1440 return density; 1441 } 1442 1443 switch (density) { 1444 case DisplayMetrics.DENSITY_LOW: 1445 return DisplayMetrics.DENSITY_MEDIUM; 1446 case DisplayMetrics.DENSITY_MEDIUM: 1447 return DisplayMetrics.DENSITY_HIGH; 1448 case DisplayMetrics.DENSITY_HIGH: 1449 return DisplayMetrics.DENSITY_XHIGH; 1450 case DisplayMetrics.DENSITY_XHIGH: 1451 return DisplayMetrics.DENSITY_MEDIUM * 2; 1452 default: 1453 return density; 1454 } 1455 } 1456 1457 /** 1458 * Get the preferred launcher icon size. This is used when custom drawables 1459 * are created (e.g., for shortcuts). 1460 * 1461 * @return dimensions of square icons in terms of pixels 1462 */ 1463 public int getLauncherLargeIconSize() { 1464 final Resources res = mContext.getResources(); 1465 final int size = res.getDimensionPixelSize(android.R.dimen.app_icon_size); 1466 1467 if ((res.getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) 1468 != Configuration.SCREENLAYOUT_SIZE_XLARGE) { 1469 return size; 1470 } 1471 1472 final int density = res.getDisplayMetrics().densityDpi; 1473 1474 switch (density) { 1475 case DisplayMetrics.DENSITY_LOW: 1476 return (size * DisplayMetrics.DENSITY_MEDIUM) / DisplayMetrics.DENSITY_LOW; 1477 case DisplayMetrics.DENSITY_MEDIUM: 1478 return (size * DisplayMetrics.DENSITY_HIGH) / DisplayMetrics.DENSITY_MEDIUM; 1479 case DisplayMetrics.DENSITY_HIGH: 1480 return (size * DisplayMetrics.DENSITY_XHIGH) / DisplayMetrics.DENSITY_HIGH; 1481 case DisplayMetrics.DENSITY_XHIGH: 1482 return (size * DisplayMetrics.DENSITY_MEDIUM * 2) / DisplayMetrics.DENSITY_XHIGH; 1483 default: 1484 return size; 1485 } 1486 } 1487 1488 /** 1489 * Returns "true" if the user interface is currently being messed with 1490 * by a monkey. 1491 */ 1492 public static boolean isUserAMonkey() { 1493 try { 1494 return ActivityManagerNative.getDefault().isUserAMonkey(); 1495 } catch (RemoteException e) { 1496 } 1497 return false; 1498 } 1499 1500 /** 1501 * Returns "true" if device is running in a test harness. 1502 */ 1503 public static boolean isRunningInTestHarness() { 1504 return SystemProperties.getBoolean("ro.test_harness", false); 1505 } 1506 1507 /** 1508 * Returns the launch count of each installed package. 1509 * 1510 * @hide 1511 */ 1512 public Map<String, Integer> getAllPackageLaunchCounts() { 1513 try { 1514 IUsageStats usageStatsService = IUsageStats.Stub.asInterface( 1515 ServiceManager.getService("usagestats")); 1516 if (usageStatsService == null) { 1517 return new HashMap<String, Integer>(); 1518 } 1519 1520 PkgUsageStats[] allPkgUsageStats = usageStatsService.getAllPkgUsageStats(); 1521 if (allPkgUsageStats == null) { 1522 return new HashMap<String, Integer>(); 1523 } 1524 1525 Map<String, Integer> launchCounts = new HashMap<String, Integer>(); 1526 for (PkgUsageStats pkgUsageStats : allPkgUsageStats) { 1527 launchCounts.put(pkgUsageStats.packageName, pkgUsageStats.launchCount); 1528 } 1529 1530 return launchCounts; 1531 } catch (RemoteException e) { 1532 Log.w(TAG, "Could not query launch counts", e); 1533 return new HashMap<String, Integer>(); 1534 } 1535 } 1536 1537 /** 1538 * Returns the usage statistics of each installed package. 1539 * 1540 * @hide 1541 */ 1542 public PkgUsageStats[] getAllPackageUsageStats() { 1543 try { 1544 IUsageStats usageStatsService = IUsageStats.Stub.asInterface( 1545 ServiceManager.getService("usagestats")); 1546 if (usageStatsService != null) { 1547 return usageStatsService.getAllPkgUsageStats(); 1548 } 1549 } catch (RemoteException e) { 1550 Log.w(TAG, "Could not query usage stats", e); 1551 } 1552 return new PkgUsageStats[0]; 1553 } 1554 1555 /** 1556 * @param userid the user's id. Zero indicates the default user 1557 * @hide 1558 */ 1559 public boolean switchUser(int userid) { 1560 try { 1561 return ActivityManagerNative.getDefault().switchUser(userid); 1562 } catch (RemoteException e) { 1563 return false; 1564 } 1565 } 1566 1567} 1568