Android Activity, lifecycle, methods and states
Activity :
An activity is a single, focused thing that the user can do. Almost all
activities interact with the user, so the Activity class takes care of creating
a window for you in which you can place your UI with setContentView(View). While
activities are often presented to the user as full-screen windows, they can
also be used in other ways: as floating windows (via a theme with windowIsFloating set) or embedded inside of another activity (using ActivityGroup). Android activity is the subclass of
ContextThemeWrapper class.
There are two methods almost all subclasses of Activity will implement:
·
onCreate(Bundle) is where you initialize your
activity. Most importantly, here you will usually call setContentView(int) with a layout resource defining
your UI, and using findViewById(int) to retrieve the widgets in that
UI that you need to interact with programmatically.
·
onPause() is where you deal with the user
leaving your activity. Most importantly, any changes made by the user should at
this point be committed (usually to the ContentProvider holding the data).
Activity Lifecycle :
Activities
in the system are managed as an activity stack. When a new activity is started,
it is placed on the top of the stack and becomes the running activity -- the
previous activity always remains below it in the stack, and will not come to
the foreground again until the new activity exits.
An
activity has essentially four states:
·
If an
activity is in the foreground of the screen (at the top of the stack), it is active or running.
·
If an
activity has lost focus but is still visible (that is, a new non-full-sized or
transparent activity has focus on top of your activity), it is paused. A paused activity is completely
alive (it maintains all state and member information and remains attached to
the window manager), but can be killed by the system in extreme low memory
situations.
·
If an
activity is completely obscured by another activity, it is stopped. It still retains all state and
member information, however, it is no longer visible to the user so its window
is hidden and it will often be killed by the system when memory is needed
elsewhere.
·
If an
activity is paused or stopped, the system can drop the activity from memory by
either asking it to finish, or simply killing its process. When it is displayed
again to the user, it must be completely restarted and restored to its previous
state.
Activity Methods :
Called when the
activity is first created. This is where you should do all of your normal
static set up: create views, bind data
to lists, etc. This method also provides you with a Bundle containing the
activity’s previously frozen state, if there was one. Always followed by
onStart().
Called after your
activity has been stopped, prior to it being started again. Always followed by
onStart().
Called when the
activity is becoming visible to the user. Followed by onResume(). If the
activity comes to the foreground or onStop() if it becomes hidden.
Called when the
activity will start interacting with the user. At this point your activity is
at the top of the activity stack, with user input going to it. Always followed
by onPause().
Called as part of the
activity lifecycle when an activity is going into the background, but has not
been killed. The counterpart to onResume(). When activity B is launched in
front of activity A, this callback will be invoked on A. B will not be created
until A’s onPause() returns, so be sure to not do anything lengthy here.
Called when you are no
longer visible to the user. You will next receive either onRestart(),
onDestory(), or nothing, depending on later user activity.
Note: This method may
not be called, in low memory situations where the syatem does not have enough
memory to keep your activity’s process running after its onPause() called.
The final call you
receive before your activity is destroyed. This can happen either because the
activity is finishing (Called finish() method), or because the system is
temporarily destroying this instance of the activity to save space. You can
distinguish between these two scenarios with the isFinishing() method.
When the Activity first time
loads the events are called
as below:
onCreate()
onStart()
onResume()
When you click on
Phone button the Activity goes to
the background and the below events are called:
onPause()
onStop()
Exit the phone dialer and the below events will be called:
onRestart()
onStart()
onResume()
When you click the back button OR try to finish() the activity the events are called as below:
onPause()
onStop()
onDestroy()
The Android OS uses a
priority queue to assist in managing activities running on the device. Based on
the state a particular Android activity is in, it will be assigned a certain
priority within the OS. This priority system helps Android identify activities
that are no longer in use, allowing the OS to reclaim memory and resources. The
following diagram illustrates the states an activity can go through, during its
lifetime:
These states can be
broken into three main groups as follows:
Active or Running - Activities are considered active or running if they are in the
foreground, also known as the top of the activity stack. This is considered the
highest priority activity in the Android Activity stack, and as such will only
be killed by the OS in extreme situations, such as if the activity tries to use
more memory than is available on the device as this could cause the UI to
become unresponsive.
Paused - When the device goes
to sleep, or an activity is still visible but partially hidden by a new,
non-full-sized or transparent activity, the activity is considered paused.
Paused activities are still alive, that is, they maintain all state and member
information, and remain attached to the window manager. This is considered to
be the second highest priority activity in the Android Activity stack and, as
such, will only be killed by the OS if killing this activity will satisfy the
resource requirements needed to keep the Active/Running Activity stable and
responsive.
Stopped - Activities that are
completely obscured by another activity are considered stopped or in the
background. Stopped activities still try to retain their state and member
information for as long as possible, but stopped activities are considered to
be the lowest priority of the three states and, as such, the OS will kill
activities in this state first to satisfy the resource requirements of higher
priority activities.
Comments
Post a Comment