ActivityManager

ACTION_REPORT_HEAP_LIMIT

static val ACTION_REPORT_HEAP_LIMIT: String

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 Intent.ACTION_SEND. Note that to match, the activity must support this action and a MIME type of "*/*".

Value: "android.app.action.REPORT_HEAP_LIMIT"

LOCK_TASK_MODE_LOCKED

static val LOCK_TASK_MODE_LOCKED: Int

Full lock task mode is active.

Value: 1

LOCK_TASK_MODE_NONE

static val LOCK_TASK_MODE_NONE: Int

Lock task mode is not active.

Value: 0

LOCK_TASK_MODE_PINNED

static val LOCK_TASK_MODE_PINNED: Int

App pinning mode is active.

Value: 2

META_HOME_ALTERNATE

static val META_HOME_ALTERNATE: String

<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>.

Value: "android.app.home.alternate"

MOVE_TASK_NO_USER_ACTION

static val MOVE_TASK_NO_USER_ACTION: Int

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.

Value: 2

MOVE_TASK_WITH_HOME

static val MOVE_TASK_WITH_HOME: Int

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

Value: 1

RECENT_IGNORE_UNAVAILABLE

static val RECENT_IGNORE_UNAVAILABLE: Int

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

Value: 2

RECENT_WITH_EXCLUDED

static val RECENT_WITH_EXCLUDED: Int

Flag for use with getRecentTasks: return all tasks, even those that have set their android.content.Intent#FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS flag.

Value: 1

addAppTask

open fun addAppTask(
    activity: Activity, 
    intent: Intent, 
    description: ActivityManager.TaskDescription?, 
    thumbnail: Bitmap
): Int

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

addApplicationStartInfoCompletionListener

open fun addApplicationStartInfoCompletionListener(
    executor: Executor, 
    listener: Consumer<ApplicationStartInfo!>
): Unit

Adds a callback that is notified when the ApplicationStartInfo record of this startup is complete. The startup is considered complete when the first frame is drawn. The callback doesn't wait for Activity.reportFullyDrawn to occur. Retrieve a copy of ApplicationStartInfo after Activity.reportFullyDrawn is called (using this callback or getHistoricalProcessStartReasons) if you need the ApplicationStartInfo.START_TIMESTAMP_FULLY_DRAWN timestamp. If the current start record has already been completed (that is, the process is not currently starting), the callback will be invoked immediately on the specified executor with the previously completed ApplicationStartInfo record. Callback will be called at most once and removed automatically after being triggered.

Note: callback is asynchronous and should be made from a background thread.

addStartInfoTimestamp

open fun addStartInfoTimestamp(
    key: Int, 
    timestampNs: Long
): Unit

Adds an optional developer supplied timestamp to the calling apps most recent ApplicationStartInfo. This is in addition to system recorded timestamps.

Note: any timestamps added after Activity.reportFullyDrawn is called are discarded.

Note: will overwrite existing timestamp if called with same key.

appNotResponding

open fun appNotResponding(reason: String): Unit

Method for the app to tell system that it's wedged and would like to trigger an ANR.

clearApplicationUserData

open fun clearApplicationUserData(): Boolean

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. It also revokes all runtime permissions that the app has acquired, clears all notifications and removes all Uri grants related to this application.

clearWatchHeapLimit

open fun clearWatchHeapLimit(): Unit

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

dumpPackageState

open fun dumpPackageState(
    fd: FileDescriptor!, 
    packageName: String!
): Unit

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.
Requires android.Manifest.permission#DUMP

getAppTaskThumbnailSize

open fun getAppTaskThumbnailSize(): Size!

Return the current design dimensions for AppTask thumbnails, for use with addAppTask.

getAppTasks

open fun getAppTasks(): MutableList<ActivityManager.AppTask!>!

Get the list of tasks associated with the calling application.

getDeviceConfigurationInfo

open fun getDeviceConfigurationInfo(): ConfigurationInfo!

Get the device configuration attributes.

getHistoricalProcessExitReasons

open fun getHistoricalProcessExitReasons(
    packageName: String?, 
    pid: Int, 
    maxNum: Int
): MutableList<ApplicationExitInfo!>

Return a list of ApplicationExitInfo records containing the reasons for the most recent app deaths.

Note: System stores this historical information in a ring buffer and only the most recent records will be returned.

Note: In the case that this application was bound to an external service with flag android.content.Context#BIND_EXTERNAL_SERVICE, the process of that external service will be included in this package's exit info.

getHistoricalProcessStartReasons

open fun getHistoricalProcessStartReasons(maxNum: Int): MutableList<ApplicationStartInfo!>

Return a list of ApplicationStartInfo records containing the information about the most recent app startups. Records accessed using this path might include "incomplete" records such as in-progress app starts. Accessing in-progress starts using this method lets you access start information early to better optimize your startup path.

Note: System stores this historical information in a ring buffer and only the most recent records will be returned.

getLargeMemoryClass

open fun getLargeMemoryClass(): Int

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.

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

getLauncherLargeIconDensity

open fun getLauncherLargeIconDensity(): Int

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

getLauncherLargeIconSize

open fun getLauncherLargeIconSize(): Int

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

getLockTaskModeState

open fun getLockTaskModeState(): Int

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.

getMemoryClass

open fun getMemoryClass(): Int

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 devices with more memory may return 24 or even higher numbers.

getMemoryInfo

open fun getMemoryInfo(outInfo: ActivityManager.MemoryInfo!): Unit

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 for how to retrieve the current trim level of your process as needed, which gives a better hint for how to manage its memory.

getMyMemoryState

open static fun getMyMemoryState(outState: ActivityManager.RunningAppProcessInfo!): Unit

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

getProcessMemoryInfo

open fun getProcessMemoryInfo(pids: IntArray!): Array<Debug.MemoryInfo!>!

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.

As of Android Q, for regular apps this method will only return information about the memory info for the processes running as the caller's uid; no other process memory info is available and will be zero. Also of Android Q the sample rate allowed by this API is significantly limited, if called faster the limit you will receive the same data as the previous call.

getProcessesInErrorState

open fun getProcessesInErrorState(): MutableList<ActivityManager.ProcessErrorStateInfo!>!

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.

As of Android TIRAMISU, for regular apps this method will only return ProcessErrorStateInfo records for the processes running as the caller's uid, unless the caller has the permission android.Manifest.permission#DUMP.

getRecentTasks

open fun getRecentTasks(
    maxNum: Int, 
    flags: Int
): MutableList<ActivityManager.RecentTaskInfo!>!

Deprecated: As of android.os.Build.VERSION_CODES#LOLLIPOP, this method is no longer available to third party applications: the introduction of document-centric recents means it can leak personal information to the caller. For backwards compatibility, it will still return a small subset of its data: at least the caller's own tasks (though see getAppTasks() for the correct supported way to retrieve that information), and possibly some other tasks such as home that are known to not be sensitive.

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.

getRunningAppProcesses

open fun getRunningAppProcesses(): MutableList<ActivityManager.RunningAppProcessInfo!>!

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.

getRunningServiceControlPanel

open fun getRunningServiceControlPanel(service: ComponentName!): PendingIntent!

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.

getRunningServices

open fun getRunningServices(maxNum: Int): MutableList<ActivityManager.RunningServiceInfo!>!

Deprecated: As of android.os.Build.VERSION_CODES#O, this method is no longer available to third party applications. For backwards compatibility, it will still return the caller's own services.

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.

getRunningTasks

open fun getRunningTasks(maxNum: Int): MutableList<ActivityManager.RunningTaskInfo!>!

Deprecated: As of android.os.Build.VERSION_CODES#LOLLIPOP, this method is no longer available to third party applications: the introduction of document-centric recents means it can leak person information to the caller. For backwards compatibility, it will still return a small subset of its data: at least the caller's own tasks, and possibly some other tasks such as home that are known to not be sensitive.

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.

isActivityStartAllowedOnDisplay

open fun isActivityStartAllowedOnDisplay(
    context: Context, 
    displayId: Int, 
    intent: Intent
): Boolean

Check if the context is allowed to start an activity on specified display. Some launch restrictions may apply to secondary displays that are private, virtual, or owned by the system, in which case an activity start may throw a SecurityException. Call this method prior to starting an activity on a secondary display to check if the current context has access to it.

isBackgroundRestricted

open fun isBackgroundRestricted(): Boolean

Query whether the user has enabled background restrictions for this app.

The user may chose to do this, if they see that an app is consuming an unreasonable amount of battery while in the background.

If true, any work that the app tries to do will be aggressively restricted while it is in the background. At a minimum, jobs and alarms will not execute and foreground services cannot be started unless an app activity is in the foreground.

Note that these restrictions stay in effect even when the device is charging.

isInLockTaskMode

open fun isInLockTaskMode(): Boolean

Deprecated: Use getLockTaskModeState instead.

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

isLowMemoryKillReportSupported

open static fun isLowMemoryKillReportSupported(): Boolean

isLowRamDevice

open fun isLowRamDevice(): Boolean

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 with 1GB or less of RAM. This is mostly intended to be used by apps to determine whether they should turn off certain features that require more RAM.

isRunningInTestHarness

open static fun isRunningInTestHarness(): Boolean

Deprecated: this method is false for all user builds. Users looking to check if their device is running in a device farm should see isRunningInUserTestHarness().

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

isRunningInUserTestHarness

open static fun isRunningInUserTestHarness(): Boolean

Returns "true" if the device is running in Test Harness Mode.

Test Harness Mode is a feature that allows devices to run without human interaction in a device farm/testing harness (such as Firebase Test Lab). You should check this method if you want your app to behave differently when running in a test harness to skip setup screens that would impede UI testing. e.g. a keyboard application that has a full screen setup page for the first time it is launched.

Note that you should not use this to determine whether or not your app is running an instrumentation test, as it is not set for a standard device running a test.

isUserAMonkey

open static fun isUserAMonkey(): Boolean

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

killBackgroundProcesses

open fun killBackgroundProcesses(packageName: String!): Unit

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.

On devices that run Android 14 or higher, third party applications can only use this API to kill their own processes.

moveTaskToFront

open fun moveTaskToFront(
    taskId: Int, 
    flags: Int
): Unit

Equivalent to calling moveTaskToFront(int,int,android.os.Bundle) with a null options argument.
Requires android.Manifest.permission#REORDER_TASKS

moveTaskToFront

open fun moveTaskToFront(
    taskId: Int, 
    flags: Int, 
    options: Bundle!
): Unit

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 android.Manifest.permission#REORDER_TASKS

removeApplicationStartInfoCompletionListener

open fun removeApplicationStartInfoCompletionListener(listener: Consumer<ApplicationStartInfo!>): Unit

Removes the provided callback set by addApplicationStartInfoCompletionListener.

restartPackage

open fun restartPackage(packageName: String!): Unit

Deprecated: This is now just a wrapper for killBackgroundProcesses(java.lang.String); the previous behavior here is no longer available to applications because it allows them to break other applications by removing their alarms, stopping their services, etc.

setProcessStateSummary

open fun setProcessStateSummary(state: ByteArray?): Unit

Set custom state data for this process. It will be included in the record of ApplicationExitInfo on the death of the current calling process; the new process of the app can retrieve this state data by calling ApplicationExitInfo.getProcessStateSummary() on the record returned by getHistoricalProcessExitReasons.

This would be useful for the calling app to save its stateful data: if it's killed later for any reason, the new process of the app can know what the previous process of the app was doing. For instance, you could use this to encode the current level in a game, or a set of features/experiments that were enabled. Later you could analyze under what circumstances the app tends to crash or use too much memory. However, it's not suggested to rely on this to restore the applications previous UI state or so, it's only meant for analyzing application healthy status.

System might decide to throttle the calls to this API; so call this API in a reasonable manner, excessive calls to this API could result a java.lang.RuntimeException.

setVrThread

open static fun setVrThread(tid: Int): Unit

Enable more aggressive scheduling for latency-sensitive low-runtime VR threads. Only one thread can be a VR thread in a process at a time, and that thread may be subject to restrictions on the amount of time it can run. If persistent VR mode is set, whatever thread has been granted aggressive scheduling via this method will return to normal operation, and calling this method will do nothing while persistent VR mode is enabled. To reset the VR thread for an application, a tid of 0 can be passed.

setWatchHeapLimit

open fun setWatchHeapLimit(pssSize: Long): Unit

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 works if the calling process has been marked as ApplicationInfo.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.