Binding Initiated

If we want a working music player, we'll need a way to call the music 0:00 playback methods in our service, when we tap buttons in our activity. 0:04 So how can we pass our service to our activity? 0:09 Let's start in main activity and talk about what we'll need to be coding. 0:13 First, we should decide where in our activity to buy into the service and 0:18 where to unbind. 0:23 Users are only able to interact with our app when it's in the foreground. 0:25 So we could probably get away with binding an onResume and 0:30 unbinding an onPause, but that could be a lot of binding just for a little pop up. 0:34 Instead, we'll do the binding and onStart and unbinding in onStop. 0:41 This way if our app is visible, we'll be bound to our service and 0:46 able to use our music player. 0:51 We could also bind an onCreate an unbind and onDestroy either one works. 0:53 All right let's get started. 1:00 At the bottom of main activity, let's add some space and 1:02 override the onStart method. 1:06 Control O onStart and make sure to pick the right one. 1:08 While we're at it, let's also override the onStop method below onStart. 1:17 When we bind it to a service, we use the bind a service method, 1:27 and just like the start service method, it takes an intent. 1:31 Back onStart, below the call to super, let's create an intent for 1:35 our player service class, intent, intent 1:41 equals new intent pass in the context 1:46 using the this keyword and pass end play service dot class. 1:51 On the next line, let's bind to our service by typing bindService. 1:59 And note that we need three arguments. 2:07 The intent for our service, something called a ServiceConnection, and any flags. 2:10 Let's pass and our intent for the first parameter skip the ServiceConnection for 2:17 now and pass in context.BIND_AUTO_CREATE for 2:23 the third parameter, to have our service automatically created when we bind to it. 2:30 Okay, let's get back to that service connection. 2:37 Binding and unbinding don't happen immediately. 2:41 The service connection is what we used to tell us, 2:45 when we're successfully connected and also when we've been disconnected. 2:47 When we call bindService, Android starts building a connection between our activity 2:53 and our service and when that connection is finally established, 2:59 Android will call the onService connected method of our service connection that we 3:04 provide as a parameter And if we ever get disconnected from our service 3:08 Android will let us know why calling the onServiceDisconnected method. 3:14 In addition to binding, we'll also need to use our service connection when we 3:20 unbind and the onStop method. 3:24 So if we need our service connection and onStart and 3:27 onStop, we'll need to create it as a field. 3:31 At the top of our class below our buttons, let's add a field for 3:35 our service connection, private ServiceConnection, 3:41 mService connection. 3:46 We still need to override the onService connected and 3:50 the onService disconnected methods of our service connection. 3:53 We could create our own class that implements service connection, 3:57 override those two methods, and then create a new instance of that class 4:01 Or we could just use an anonymous class. 4:08 If you've never used anonymous classes before, you're lying. 4:17 There's one right here. 4:21 An anonymous class is pretty much just a way to extend a class 4:24 without having to create a whole new class. 4:28 It's a way for us to add functionality to an object 4:31 without needing to create a new type of object. 4:34 Let's set our ServiceConnection to be = to a new anonymous ServiceConnection class. 4:38 So = new ServiceConnection. 4:45 Hit enter and there we go. 4:50 Back in the on start method let's pass on our new ServiceConnection field as 4:53 the second parameter to bind service. 4:58 And an onStop below the call to super, let's call the unbindService method. 5:06 And, as promised, it takes a service connection parameter. 5:15 Let's pass that in. 5:19 We're almost done. 5:23 But unfortunately, unbindService can throw an error if the service isn't bound. 5:25 One way this can happen is if our call to bind the service 5:31 wasn't successful in the first place. 5:34 If we didn't bind to our service, how can we expect to unbind from it? 5:37 We'll fix this by adding a boolean field named mBound to track whether or 5:42 not we are bound to the service. 5:47 Below our key declaration, Let's 5:49 add this new field private boolean mBound. 5:55 And let's set it = false. 6:01 Now, we need to update our inbound variable when our service is bound and 6:06 when it's unbound. 6:10 But how can we tell when our service is bound. 6:12 That's right! 6:16 The onServiceConnected method of our service connection. 6:17 And when our services unbound or 6:21 disconnected, the onServiceDisconnected method will be called. 6:23 So when onServiceConnected, let set mBound = to true and 6:28 then onServiceDisconnected Let's set mBound equal to false. 6:35 Last but not least, let's make sure we're only calling 6:46 unbind service if our service is actually bound, so 6:51 if mBound And add the other bracket at the bottom. 6:56 Then right below onbindService, let's set mBound to false. 7:03 On service disconnected is only called when something unexpected happens. 7:13 So calling unbind a service won't result in a call to on service disconnected, 7:19 which is why we're responsible for 7:24 updating mBound after calling unbind service. 7:26 We're almost done binding to our service. 7:31 Can you hear the music yet, me neither, but 7:33 I think we might hear some in this next video. 7:38