The Activity Life Cycle

The Long Story, by Android
Activity States
- Running - The activity is in the foreground of the screen and has user focus.
- Paused - Another activity is in the foreground and has focus, but this one is still visible. A paused activity is completely alive (the Activity object is retained in memory, it maintains all state information, and remains attached to the window manager), but can be killed by the system in extremely low memory situations.
- Stopped - The activity is completely obscured by another activity. A stopped activity is still alive (the Activity object is retained in memory, it maintains all state and member information, but is not attached to the window manager), but it is no longer visible to the user and it can be killed by the system when memory is needed elsewhere.
The Life Cycle
- The user can override the callback methods indicated in the picture.
- The entire lifetime of an activity happens between the call to onCreate() and the call to onDestroy().
- The visible lifetime of an activity happens between calls to onStart() and calls to onStop(). During these times the user can see at least some of the activity on-screen.
- The foreground lifetime of an activity happens between calls to onResume() and calls to onPause(). During this time, the activity is in front of all other activities on screen and has user input focus, i.e., the user can see the complete activity on-screen and interact with it.
Implementing Lifecycle Callbacks
- All of the callback methods are hooks that you can override to do appropriate work when the state of your activity changes.
- Implementations of lifecycle methods must always call the superclass implementation before doing any work.
- onCreate() - Called when the activity is first created. An activity should perform setup of "global" state (such as defining layout). This method is passed a Bundle object containing the activity's previous state, if that state was captured. Always followed by onStart().
```
//----The activity is being created.
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
```
- onStart() - Called just before the activity becomes visible to the user. Followed by onResume() if the activity comes to the foreground, or onStop() if it becomes hidden.
```
//----The activity is about to become visible.
    @Override
    protected void onStart() {
        super.onStart();
    }
```
- onResume() - Called just before the activity starts interacting with the user. Always followed by onPause(), normally after some user interaction.
```
//----The activity has become visible (it is now "resumed").
    @Override
    protected void onResume() {
        super.onResume();
    }
```
- onPause() - Called when the system is about to resume another activity. This method is typically used to commit unsaved changes to persistent data, stop animations and other things that may be consuming CPU, and so on. It should do whatever it does very quickly, because the next activity will not be resumed until the method returns. Followed by onResume() if the activity returns back to the front, or by onStop() if it becomes invisible to the user.
```
//----Another activity is taking focus (this activity is about to be "paused").
    @Override
    protected void onPause() {
        super.onPause();
    }
```
- onStop() - Called when the activity is no longer visible to the user, either because it is being destroyed or because a resumed activity has come in front of it. Followed by onRestart() if the activity is going to be resumed, or by onDestroy() if the activity is going to be destroyed.
```
//----The activity is no longer visible (it is now "stopped")
    @Override
    protected void onStop() {
        super.onStop();
    }
```
- onRestart() - Called after the activity has been stopped, just prior to it being started again. Always followed by onStart().
```
//----The activity is about to start, after having stopped.
    @Override
    protected void onRestart() {
        super.onRestart();
    }
```
- onDestroy() - Called before the activity is destroyed. This is the final call that the activity will receive. It could be called either because the activity is finishing (someone called finish() on it), 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. All resources should be released by here.
```
//----The activity is about to be destroyed.
    @Override
    protected void onDestroy() {
        super.onDestroy();
    } 
```
- The order of lifecycle callbacks is well defined, particularly when the activities are in the same process and one is starting the other. Here's the order of callbacks that occur when Activity A starts Activity B:
  - Activity A's onPause() is called.
  - Activity B's onCreate(), onStart(), and onResume() are called.
  - If Activity A is no longer visible its onStop() is called.
Watching Callbacks (while listening to music)
- The source code is
  MainActivity.java
  activity_life_cycle.xml
  PauserWindow.java
  activity_pauser_window.xml
  StopperWindow.java
  activity_stopper_window.xml
  strings.xml
  AndroidManifest.xml
- It uses a MP3 as raw resource
  - Create a folder called raw under the res folder.
  - Put the MP3 into the raw folder
    spike_electric.mp3
- Run the app and watch the callbacks being logged.
Saving Activity State
- When an activity is paused or stopped its state is retained, because the Activity object is held in memory.
- When an activity is destroyed in order to recover memory, the Activity object is destroyed. The system cannot resume it with its state intact. Instead, the system must recreate the Activity object if the user navigates back to it.
- The onSaveInstanceState() callback is called before an activity is made vulnerable to being killed.
  - A Bundle object is passed in, where state information can be stored.
  - onSaveInstanceState() is called before onStop(), and possibly before onPause().
  - onSaveInstanceState() is called only if the activity might be killed.
  - The default implementation stores all UI information, so call super.onSaveInstanceState() in your version.
- The onRestoreInstanceState() is called when an activity is being recreated after being killed.
  - onRestoreInstanceState() is called after onStart().
  - The Bundle is also passed in to onCreate() so that state can be restored. Most implementations use onCreate() to restore state, but sometimes it's convenient to do it here.
  - The default implementation restores all UI information, so call super.onRestoreInstanceState() in your version.