Logging the Lifecycle Methods5:40 with Ben Deitch
We've learned a lot about the activity lifecycle. In this video we'll go through a sample app and see the activity lifecycle in action!
[MUSIC] 0:00 All right, now that we've got a pretty good idea of what the activity life cycle 0:04 is and when each of the life cycle methods will be called, 0:09 let's jump into a sample app and run a few tests to see these in action. 0:12 Here's the app we'll be using to test out the activity life cycle. 0:17 Before we get started let's take a minute to see how the app works. 0:21 First, there's a custom activity called LoggingActivity. 0:25 Every activity that extends LoggingActivity 0:29 will log a message each time a lifecycle method is called. 0:32 Next we have MainActivity. 0:36 MainActivity is the entry point of the application. 0:39 And has two buttons that launch the other two activities. 0:42 One button launches opaque activity and 0:46 the other button launches transparent activity. 0:49 MainActivity, OpaqueActivity, and 0:52 TransparentActivity all extend the LoggingActivity. 0:55 So we should see a log message for each and 0:59 every life cycle method that gets called for these activities. 1:02 Let's run the app and see what gets called. 1:06 Before we start parsing the log cat, let's filter it by our tag, life cycle example. 1:13 Just as we would expect from the diagram, the methods called so 1:23 far are onCreate, onStart and onResume from MainActivity. 1:29 And MainActivity is currently in a running state at the top of the activity stack. 1:35 What do we expect to happen if we launch OpaqueActivity? 1:41 If OpaqueActivity is launched, MainActivity won't be visible anymore. 1:46 So we would expect to see onPause and onStop from MainActivity. 1:51 And for OpaqueActivity to be the running activity, 1:56 we would expect to see onCreate, onStart, and onResume from OpaqueActivity. 2:00 But what will be the order of these methods? 2:07 Take a minute to think about it. 2:10 Feel free to pause me, I'll be right here. 2:13 All right, got your guess? 2:17 Let's find out. 2:19 If you guessed MainActivity is onPause, followed by onCreate, 2:25 onStart, and onResume from OpaqueActivity, and 2:30 finishing up with MainActivity is onStop, then you're right. 2:33 Let's take a minute to see why this is the case. 2:39 OnPause is called when you can no longer interact with an activity. 2:42 This being called first, means main activity is removed from the top of 2:46 the activity stack, which is necessary if we're going to have a new activity on top. 2:51 Next comes onCreate, onStart. 2:56 And onResume, from OpaqueActivity. 2:59 OpaqueActivity is now on top of the activity stack, and ready for 3:03 user interaction. 3:07 Lastly, MainActivities on stop is called. 3:09 OnStop is called when the activity is no longer visible. 3:13 Since OpaqueActivity isn't visible until after onStart and 3:16 since onResume will immediately follow onStart. 3:21 MainActivity's onStop method won't be called until after 3:25 OpaqueActivity's onResume method. 3:29 Now that we know which life cycle methods were called to get us here, 3:32 let's hit the back button and 3:35 see which life cycle methods get called when we go back to Main Activity. 3:37 Looks like it's the same calls as last time, 3:43 except we've switched MainActivity and OpaqueActivity. 3:46 The only difference is the call to onDestroy and OpaqueActivity. 3:51 Leaving an activity by hitting the back button is our way of telling 3:57 Android that we're finished with an activity. 4:01 That's why Android destroys OpaqueActivity instead of leaving it in a stopped state. 4:04 Now that we're back in MainActivity, 4:10 let's see what happens when we launch the TransparentActivity. 4:12 Go ahead and pause me if you'd like to take a guess at what happens. 4:16 Here we go. 4:21 Turns out, it's exactly like when we launched the OpaqueActivity 4:25 except OnStop isn't called in MainActivity. 4:29 Since we can still see main activity behind our TransparentActivity. 4:33 MainActivity is on a pause state and onStop isn't called. 4:37 Cool. 4:43 For the last test, let's see what happens when we hit the home button. 4:44 First, TransparentActivity is pause. 4:49 And then, both MainActivity and TransparentActivity are stopped. 4:53 When we hit the Home button, 4:59 we're telling Android that we're moving on to something else. 5:00 Android doesn't know if we'll be back or not, so 5:05 it keeps our activities around in a stopped state, in case we return. 5:08 Keep in mind that Android may kill stopped activities to free up memory. 5:12 You've learned a lot about the activity lifecycle. 5:17 In the next video we'll learn how we can hook into our activities lifecycle 5:20 to save data using shared preferences. 5:24 Also, if you'd like to try these tests on your own, or are curious about how this 5:27 app is programmed there's a link to the GitHub project in the teacher's notes. 5:32 And it's included below in the project files as well. 5:36
You need to sign up for Treehouse in order to download course files.Sign up