MemoryBudget

Kotlin |Java

class MemoryBudget : Parcelable

kotlin.Any
↳	android.content.pm.MemoryBudget

Memory budget information for an application. entries are retrieved from <memory-budget> entries in an application's manifest, and can be obtained through ApplicationInfo.getMemoryBudgets.

A MemoryBudget that is declared in the Android manifest sets a ceiling on the memory available to the package or to a process within the package. MemoryBudget declarations may appear at the application level and at the process level. The two are independent and neither overrides the other. In practice, however, the smaller budget dominates.

Every MemoryBudget has a state and a feature; these two attributes determine if and when the MemoryBudget is applicable.

The state is the operational state of the process or the application, and is one of Foreground, Perceptible, or Background.
The feature selects for device form-factor and is one of Unspecified, TV, Auto, and Watch.

A MemoryBudget is applicable to a process if its feature is Unspecified or if its feature matches the device's form-factor. A MemoryBudget applies to a process if it is applicable to the process and the MemoryBudget state is less than or equal to the operational state of the process. Applications also have state, which is roughly the lowest state of any process running in the application.

A MemoryBudget declares an upper bound on the amount of memory the process or application may use. The upper bound is computed from three factors:

maxMb is a baseline amount of memory, expressed in MiB. This must be positive.
additionalBytesPerPixel is a scaling factor: bytes per display pixel. This must be non-negative and defaults to zero.
additionalMbPerDensity is a scaling factor: MiB times display density. This must be non-negative and defaults to zero.

The actual limit is calculated as the maxMb value plus the scale factors applied to the default display of the device.

If a process RSS exceeds its declared budget then the kernel will force it to drop memory. This usually means dropping file cache pages but it may also mean that some memory will be moved to swap. In most cases this happens without any impact on the process, but if the process is actively using more memory than the budget limit, the process will slow down as pages are swapped out and then back in. In the limit, the process may ANR.

Summary

Constants
static Int	`FEATURE_AUTOMOTIVE` Indicates that this `MemoryBudget` applies to the automotive form factor.
static Int	`FEATURE_LEANBACK` Indicates that this `MemoryBudget` applies to the TV form factor.
static Int	`FEATURE_UNSPECIFIED` Indicates that this `MemoryBudget` is generic, and can apply to any form factor.
static Int	`FEATURE_WATCH` Indicates that this `MemoryBudget` applies to the watch form factor.
static Int	`STATE_BACKGROUND` Indicates that this `MemoryBudget` can apply to a process that is in the background.
static Int	`STATE_FOREGROUND` Indicates that this `MemoryBudget` can apply to a process that is in the foreground (or in a less important state).
static Int	`STATE_PERCEPTIBLE` Indicates that this `MemoryBudget` can apply to a process that is perceptible (or in a less important state).

Inherited constants

From class Parcelable

Int

CONTENTS_FILE_DESCRIPTOR

Descriptor bit used with describeContents(): indicates that the Parcelable object's flattened representation includes a file descriptor.

Int

PARCELABLE_WRITE_RETURN_VALUE

Flag for use with writeToParcel: the object being written is a return value, that is the result of a function such as "Parcelable someFunction()", "void someFunction(out Parcelable)", or "void someFunction(inout Parcelable)". Some implementations may want to release resources at this point.

Public methods
Int	`describeContents()` Describe the kinds of special objects contained in this Parcelable instance's marshaled representation.
Boolean	`equals(other: Any?)` Indicates whether some other object is "equal to" this one.
Long	`getAdditionalBytesPerDisplayPixel()` Returns the additional bytes per pixel that this `MemoryBudget`'s limit will be raised by.
Long	`getAdditionalMbPerDensity()` Returns the additional memory (in MiB) that this `MemoryBudget`'s limit will be raised by, based on the screen density of the device.
Int	`getFeature()` Returns the form factor to which this `MemoryBudget` applies.
Long	`getMaxMb()` Returns the memory limit (in MiB) that this `MemoryBudget` represents.
Int	`getState()` Returns the process state in which this `MemoryBudget` applies.
Int	`hashCode()` Returns a hash code value for the object.
String	`toString()` Returns a string representation of the object.
Unit	`writeToParcel(dest: Parcel, flags: Int)` Flatten this object in to a Parcel.

Properties
static Parcelable.Creator<MemoryBudget!>	`CREATOR`

Parameters
`dest`	Parcel: This value cannot be `null`.
`flags`	Int: Additional flags about how the object should be written. May be 0 or `PARCELABLE_WRITE_RETURN_VALUE`. Value is either `0` or a combination of the following: `PARCELABLE_WRITE_RETURN_VALUE`

MemoryBudget

Summary

Constants

FEATURE_AUTOMOTIVE

FEATURE_LEANBACK

FEATURE_UNSPECIFIED

FEATURE_WATCH

STATE_BACKGROUND

STATE_FOREGROUND

STATE_PERCEPTIBLE

Public methods

describeContents

equals

getAdditionalBytesPerDisplayPixel

getAdditionalMbPerDensity

getFeature

getMaxMb

getState

hashCode

toString

writeToParcel

Properties

CREATOR