ActivityManager

Action an app can implement to handle reports from setWatchHeapLimit(long). If your package has an activity handling this action, it will be launched with the heap data provided to it the same way as ACTION_SEND. Note that to match the activty must support this action and a MIME type of "*/*".

Full lock task mode is active.

Lock task mode is not active.

App pinning mode is active.

<meta-data> name for a 'home' Activity that declares a package that is to be uninstalled in lieu of the declaring one. The package named here must be signed with the same certificate as the one declaring the <meta-data>.

Flag for moveTaskToFront(int, int): don't count this as a user-instigated action, so the current activity will not receive a hint that the user is leaving.

Flag for moveTaskToFront(int, int): also move the "home" activity along with the task, so it is positioned immediately behind the task.

Provides a list that does not contain any recent tasks that currently are not available to the user.

Flag for use with getRecentTasks(int, int): return all tasks, even those that have set their FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS flag.

Add a new ActivityManager.AppTask for the calling application. This will create a new recents entry that is added to the end of all existing recents.

Permits an application to erase its own data from disk. This is equivalent to the user choosing to clear the app's data from within the device settings UI. It erases all dynamic data associated with the app -- its private data and data in its private area on external storage -- but does not remove the installed application itself, nor any OBB files.

Clear a heap watch limit previously set by setWatchHeapLimit(long).

Perform a system dump of various state associated with the given application package name. This call blocks while the dump is being performed, so should not be done on a UI thread. The data will be written to the given file descriptor as text. An application must hold the DUMP permission to make this call.

Return the current design dimensions for ActivityManager.AppTask thumbnails, for use with addAppTask(Activity, Intent, ActivityManager.TaskDescription, Bitmap).

Get the list of tasks associated with the calling application.

Get the device configuration attributes.

Return the approximate per-application memory class of the current device when an application is running with a large heap. This is the space available for memory-intensive applications; most applications should not need this amount of memory, and should instead stay with the getMemoryClass() limit. The returned value is in megabytes. This may be the same size as getMemoryClass() on memory constrained devices, or it may be significantly larger on devices with a large amount of available RAM.

The is the size of the application's Dalvik heap if it has specified android:largeHeap="true" in its manifest.

Get the preferred density of icons for the launcher. This is used when custom drawables are created (e.g., for shortcuts).

Get the preferred launcher icon size. This is used when custom drawables are created (e.g., for shortcuts).

Return the current state of task locking. The three possible outcomes are LOCK_TASK_MODE_NONE, LOCK_TASK_MODE_LOCKED and LOCK_TASK_MODE_PINNED.

Return the approximate per-application memory class of the current device. This gives you an idea of how hard a memory limit you should impose on your application to let the overall system work best. The returned value is in megabytes; the baseline Android memory class is 16 (which happens to be the Java heap limit of those devices); some device with more memory may return 24 or even higher numbers.

Return general information about the memory state of the system. This can be used to help decide how to manage your own memory, though note that polling is not recommended and ComponentCallbacks2.onTrimMemory(int) is the preferred way to do this. Also see getMyMemoryState(ActivityManager.RunningAppProcessInfo) for how to retrieve the current trim level of your process as needed, which gives a better hint for how to manage its memory.

Return global memory state information for the calling process. This does not fill in all fields of the ActivityManager.RunningAppProcessInfo. The only fields that will be filled in are pid, uid, lastTrimLevel, importance, lru, and importanceReasonCode.

Return information about the memory usage of one or more processes.

Note: this method is only intended for debugging or building a user-facing process management UI.

Returns a list of any processes that are currently in an error condition. The result will be null if all processes are running properly at this time.

Note: this method is only intended for debugging and presenting task management user interfaces. This should never be used for core logic in an application, such as deciding between different behaviors based on the information found here. Such uses are not supported, and will likely break in the future. For example, if multiple applications can be actively running at the same time, assumptions made about the meaning of the data here for purposes of control flow will be incorrect.

Returns a list of application processes that are running on the device.

Note: this method is only intended for debugging or building a user-facing process management UI.

Returns a PendingIntent you can start to show a control panel for the given running service. If the service does not have a control panel, null is returned.

Return a list of the services that are currently running.

Note: this method is only intended for debugging or implementing service management type user interfaces.

Return a list of the tasks that are currently running, with the most recent being first and older ones after in order. Note that "running" does not mean any of the task's code is currently loaded or activity -- the task may have been frozen by the system, so that it can be restarted in its previous state when next brought to the foreground.

Note: this method is only intended for debugging and presenting task management user interfaces. This should never be used for core logic in an application, such as deciding between different behaviors based on the information found here. Such uses are not supported, and will likely break in the future. For example, if multiple applications can be actively running at the same time, assumptions made about the meaning of the data here for purposes of control flow will be incorrect.

Return whether currently in lock task mode. When in this mode no new tasks can be created or switched to.

Returns true if this is a low-RAM device. Exactly whether a device is low-RAM is ultimately up to the device configuration, but currently it generally means something in the class of a 512MB device with about a 800x480 or less screen. This is mostly intended to be used by apps to determine whether they should turn off certain features that require more RAM.

Returns "true" if device is running in a test harness.

Returns "true" if the user interface is currently being messed with by a monkey.

Have the system immediately kill all background processes associated with the given package. This is the same as the kernel killing those processes to reclaim memory; the system will take care of restarting these processes in the future as needed.

You must hold the permission KILL_BACKGROUND_PROCESSES to be able to call this method.

Ask that the task associated with a given task ID be moved to the front of the stack, so it is now visible to the user. Requires that the caller hold permission REORDER_TASKS or a SecurityException will be thrown.

Equivalent to calling moveTaskToFront(int, int, Bundle) with a null options argument.

Request that the system start watching for the calling process to exceed a pss size as given here. Once called, the system will look for any occasions where it sees the associated process with a larger pss size and, when this happens, automatically pull a heap dump from it and allow the user to share the data. Note that this request continues running even if the process is killed and restarted. To remove the watch, use clearWatchHeapLimit().

This API only work if the calling process has been marked as FLAG_DEBUGGABLE or this is running on a debuggable (userdebug or eng) build.

Callers can optionally implement ACTION_REPORT_HEAP_LIMIT to directly handle heap limit reports themselves.