Stopping Services7:18 with Ben Deitch
In this video we’ll learn what it means to stop a started Service!
We just killed our process and watched it rise from the grave. 0:00 But why? 0:04 Well, this is one of the big differences between a service and an activity. 0:06 When you kill an app's process, everything in that app is killed, 0:11 including all the activities and services. 0:15 But depending on what we return from onStartCommand the services might 0:19 come right back. 0:23 Let's take another look at what we're returning from onStartCommand look 0:26 down here we're returning a constant from the service class 0:30 called START_REDELIVER_INTENT. 0:35 This is one of the three values that we can return from onStartCommand to tell 0:37 Android how to handle our service being killed, while it's still working. 0:42 But how do we determine if our service is still working or not? 0:47 Easy. 0:52 A service is considered started if onStartCommand has returned a value. 0:53 And it's not considered stopped until it's explicitly stopped. 1:00 So the return value from onStartCommand represents what we want Android to do 1:05 if our service's process is killed after we've returned from onStartCommand, 1:11 but before being stopped. 1:17 Let's take a quick tour to talk more about stopping a service. 1:21 Stopping a service, let's Android know that we're finished with it and 1:25 frees up more room for other applications. 1:29 We can stop a service by calling stopSelf from the service itself or 1:32 if we need to stop our service from the outside We can call stopService and 1:38 pass an intent, just like when we started our service. 1:44 Now let's see how we can stop our download service when it's done working. 1:48 The purpose of download service is to download one song. 1:54 Remember that we call start service for each song in the playlist. 1:59 So when that one song is finished downloading, 2:04 our service is done working and it would be a good time to stop the service. 2:08 Over and download handler and side the handle message 2:13 method is the call to download song. 2:18 Once this call is finished, our song has been downloaded. 2:25 Let's add a line after this call and stop our service. 2:30 At first, since we don't have access to our service, 2:35 it seems like we should do this by calling stop service and passing an intent. 2:39 but this isn't a good approach for us. 2:45 Calling stop service, stops the service entirely. 2:48 If we called stop service after only the first song, 2:53 we'd be stopping the service before it finished working. 2:57 Not good. 3:00 Instead, there's a version of the stop self method that takes an integer When 3:02 onStartCommand is called, one of the parameters is an integer named startID. 3:07 Calling stops self and passing in this startID makes sure that we don't 3:16 stop our service until it has handled all of the startIDs. 3:21 Okay, so we need to get the startID from onStartCommand and pass it to our handler. 3:26 Then, when downloading is finished, 3:33 we need to use the correctonStartCommand and call stopSelf on our service. 3:36 Back in download service, right above where we send our message, 3:42 let's attach the startID to our message using one of the argument properties. 3:47 Each message object has two integer properties named arg1 and 3:53 arg2, which we can use for passing arguments. 3:59 Let's set arg1 Equal to startId. 4:04 Now, we just need to call stop self on our service when our handler's done working. 4:10 An easy way to do this would be to just pass a reference to our service to 4:17 our handler. 4:22 And the bottom of the OnCreate Let's type 4:23 mhandler.setService. 4:29 And pass in the keyword this to pass in our service. 4:35 Then let's use Alt Enter to create a setter. 4:40 Hit Enter twice to accept the defaults and there we go. 4:47 Let's flip back to the download handler class and see what we've got. 4:52 Looks like we've got a field for our service named mService. 4:58 And we've got a new method called, setService as well. 5:04 The last thing we need to do, 5:09 is use mService to call stop self at the bottom of handle message. 5:10 Let's type mService.stopSelf and 5:15 pass in msg.arg1 to make sure that we only 5:20 stop the service if it's handled all of our startIDs. 5:25 Great work. 5:33 Let's quickly test this out to see what's different. 5:34 Make sure we also have open the Android device monitor. 5:42 And hit the Download button. 5:49 Give it ten seconds to download a song. 5:53 And then let's kill the process. 6:02 and there's our message saying, it'll restart and 6:09 if we wait we should see our service restart and 6:14 finish downloading our songs just like last time. 6:20 I'll just skip to the end, but 6:23 pause me until the downloads are finished if you're following along. 6:25 Okay. 6:30 So what happens if we kill the process once all the songs have downloaded? 6:31 Let's do it. 6:36 And if we look to the lawn, it doesn't look like our service was rescheduled. 6:42 Perfect. 6:49 That's why it's so important to make sure that we stop our services. 6:51 If we don't, they can hog system existing resources almost forever. 6:55 Services are an incredibly powerful tool and any Android developers tool belt But 7:01 with great power comes great responsibility, and 7:06 if we forget to stop our started services, then we won't have very happy users. 7:09 In the next video, we'll get back to where we left off with onStartCommand. 7:14
You need to sign up for Treehouse in order to download course files.Sign up