[MUSIC]

All right, now that we've got a pretty good idea of what the activity life cycle

is and when each of the life cycle methods will be called,

let's jump into a sample app and run a few tests to see these in action.

Here's the app we'll be using to test out the activity life cycle.

Before we get started let's take a minute to see how the app works.

First, there's a custom activity called LoggingActivity.

Every activity that extends LoggingActivity

will log a message each time a lifecycle method is called.

Next we have MainActivity.

MainActivity is the entry point of the application.

And has two buttons that launch the other two activities.

One button launches opaque activity and

the other button launches transparent activity.

MainActivity, OpaqueActivity, and

TransparentActivity all extend the LoggingActivity.

So we should see a log message for each and

every life cycle method that gets called for these activities.

Let's run the app and see what gets called.

Before we start parsing the log cat, let's filter it by our tag, life cycle example.

Just as we would expect from the diagram, the methods called so

far are onCreate, onStart and onResume from MainActivity.

And MainActivity is currently in a running state at the top of the activity stack.

What do we expect to happen if we launch OpaqueActivity?

If OpaqueActivity is launched, MainActivity won't be visible anymore.

So we would expect to see onPause and onStop from MainActivity.

And for OpaqueActivity to be the running activity,

we would expect to see onCreate, onStart, and onResume from OpaqueActivity.

But what will be the order of these methods?

Take a minute to think about it.

Feel free to pause me, I'll be right here.

All right, got your guess?

Let's find out.

If you guessed MainActivity is onPause, followed by onCreate,

onStart, and onResume from OpaqueActivity, and

finishing up with MainActivity is onStop, then you're right.

Let's take a minute to see why this is the case.

OnPause is called when you can no longer interact with an activity.

This being called first, means main activity is removed from the top of

the activity stack, which is necessary if we're going to have a new activity on top.

Next comes onCreate, onStart.

And onResume, from OpaqueActivity.

OpaqueActivity is now on top of the activity stack, and ready for

user interaction.

Lastly, MainActivities on stop is called.

OnStop is called when the activity is no longer visible.

Since OpaqueActivity isn't visible until after onStart and

since onResume will immediately follow onStart.

MainActivity's onStop method won't be called until after

OpaqueActivity's onResume method.

Now that we know which life cycle methods were called to get us here,

let's hit the back button and

see which life cycle methods get called when we go back to Main Activity.

Looks like it's the same calls as last time,

except we've switched MainActivity and OpaqueActivity.

The only difference is the call to onDestroy and OpaqueActivity.

Leaving an activity by hitting the back button is our way of telling

Android that we're finished with an activity.

That's why Android destroys OpaqueActivity instead of leaving it in a stopped state.

Now that we're back in MainActivity,

let's see what happens when we launch the TransparentActivity.

Go ahead and pause me if you'd like to take a guess at what happens.

Here we go.

Turns out, it's exactly like when we launched the OpaqueActivity

except OnStop isn't called in MainActivity.

Since we can still see main activity behind our TransparentActivity.

MainActivity is on a pause state and onStop isn't called.

Cool.

For the last test, let's see what happens when we hit the home button.

First, TransparentActivity is pause.

And then, both MainActivity and TransparentActivity are stopped.

When we hit the Home button,

we're telling Android that we're moving on to something else.

Android doesn't know if we'll be back or not, so

it keeps our activities around in a stopped state, in case we return.

Keep in mind that Android may kill stopped activities to free up memory.

You've learned a lot about the activity lifecycle.

In the next video we'll learn how we can hook into our activities lifecycle

to save data using shared preferences.

Also, if you'd like to try these tests on your own, or are curious about how this

app is programmed there's a link to the GitHub project in the teacher's notes.

And it's included below in the project files as well.