A Service is an application component representing either an application's desire
to perform a longer-running operation while not interacting with the user
or to supply functionality for other applications to use.

This class was deprecated
in API level 13.
New applications should use Fragments instead of this class;
to continue to run on older devices, you can use the v4 support library
which provides a version of the Fragment API that is compatible down to
DONUT.

You should implement onTrimMemory(int) to incrementally release memory based on current
system constraints. Using this callback to release your resources helps provide a more
responsive system overall, but also directly benefits the user experience for
your app by allowing the system to keep your process alive longer. That is,
if you don't trim your resources based on memory levels defined by this callback,
the system is more likely to kill your process while it is cached in the least-recently used
(LRU) list, thus requiring your app to restart and restore all state when the user returns to it.

The values provided by onTrimMemory(int) do not represent a single linear progression of
memory limits, but provide you different types of clues about memory availability:

TRIM_MEMORY_RUNNING_LOWThe device is running much lower on memory.
Your app is running and not killable, but please release unused resources to improve system
performance (which directly impacts your app's performance).

TRIM_MEMORY_RUNNING_CRITICALThe device is running extremely low on memory.
Your app is not yet considered a killable process, but the system will begin killing
background processes if apps do not release resources, so you should release non-critical
resources now to prevent performance degradation.

When your app's visibility changes:

TRIM_MEMORY_UI_HIDDENYour app's UI is no longer visible, so this is a good
time to release large resources that are used only by your UI.

When your app's process resides in the background LRU list:

TRIM_MEMORY_BACKGROUNDThe system is running low on memory and your process is
near the beginning of the LRU list. Although your app process is not at a high risk of being
killed, the system may already be killing processes in the LRU list, so you should release
resources that are easy to recover so your process will remain in the list and resume
quickly when the user returns to your app.

TRIM_MEMORY_MODERATEThe system is running low on memory and your process is
near the middle of the LRU list. If the system becomes further constrained for memory, there's a
chance your process will be killed.

TRIM_MEMORY_COMPLETEThe system is running low on memory and your process is
one of the first to be killed if the system does not recover memory now. You should release
absolutely everything that's not critical to resuming your app state.

Note: When the system begins
killing processes in the LRU list, although it primarily works bottom-up, it does give some
consideration to which processes are consuming more memory and will thus provide more gains in
memory if killed. So the less memory you consume while in the LRU list overall, the better
your chances are to remain in the list and be able to quickly resume.

More information about the different stages of a process lifecycle (such as what it means
to be placed in the background LRU list) is provided in the Processes and Threads
document.

Level for onTrimMemory(int): the process is around the middle
of the background LRU list; freeing memory can help the system keep
other processes running later in the list for better overall performance.

Level for onTrimMemory(int): the process is not an expendable
background process, but the device is running extremely low on memory
and is about to not be able to keep any background processes running.

public
static
final
int
TRIM_MEMORY_MODERATE

Level for onTrimMemory(int): the process is around the middle
of the background LRU list; freeing memory can help the system keep
other processes running later in the list for better overall performance.

Constant Value:
60
(0x0000003c)

public
static
final
int
TRIM_MEMORY_RUNNING_CRITICAL

Level for onTrimMemory(int): the process is not an expendable
background process, but the device is running extremely low on memory
and is about to not be able to keep any background processes running.
Your running process should free up as many non-critical resources as it
can to allow that memory to be used elsewhere. The next thing that
will happen after this is onLowMemory() called to report that
nothing at all can be kept in the background, a situation that can start
to notably impact the user.

Constant Value:
15
(0x0000000f)

public
static
final
int
TRIM_MEMORY_RUNNING_LOW

Level for onTrimMemory(int): the process is not an expendable
background process, but the device is running low on memory.
Your running process should free up unneeded resources to allow that
memory to be used elsewhere.

Constant Value:
10
(0x0000000a)

public
static
final
int
TRIM_MEMORY_RUNNING_MODERATE

Level for onTrimMemory(int): the process is not an expendable
background process, but the device is running moderately low on memory.
Your running process may want to release some unneeded resources for
use elsewhere.

Constant Value:
5
(0x00000005)

public
static
final
int
TRIM_MEMORY_UI_HIDDEN

Level for onTrimMemory(int): the process had been showing
a user interface, and is no longer doing so. Large allocations with
the UI should be released at this point to allow memory to be better
managed.

Constant Value:
20
(0x00000014)

Public Methods

public
abstract
void
onTrimMemory(int level)

Called when the operating system has determined that it is a good
time for a process to trim unneeded memory from its process. This will
happen for example when it goes in the background and there is not enough
memory to keep as many background processes running as desired. You
should never compare to exact values of the level, since new intermediate
values may be added -- you will typically want to compare if the value
is greater or equal to a level you are interested in.