If we want a working music player, we'll need a way to call the music

playback methods in our service, when we tap buttons in our activity.

So how can we pass our service to our activity?

Let's start in main activity and talk about what we'll need to be coding.

First, we should decide where in our activity to buy into the service and

where to unbind.

Users are only able to interact with our app when it's in the foreground.

So we could probably get away with binding an onResume and

unbinding an onPause, but that could be a lot of binding just for a little pop up.

Instead, we'll do the binding and onStart and unbinding in onStop.

This way if our app is visible, we'll be bound to our service and

able to use our music player.

We could also bind an onCreate an unbind and onDestroy either one works.

All right let's get started.

At the bottom of main activity, let's add some space and

override the onStart method.

Control O onStart and make sure to pick the right one.

While we're at it, let's also override the onStop method below onStart.

When we bind it to a service, we use the bind a service method,

and just like the start service method, it takes an intent.

Back onStart, below the call to super, let's create an intent for

our player service class, intent, intent

equals new intent pass in the context

using the this keyword and pass end play service dot class.

On the next line, let's bind to our service by typing bindService.

And note that we need three arguments.

The intent for our service, something called a ServiceConnection, and any flags.

Let's pass and our intent for the first parameter skip the ServiceConnection for

now and pass in context.BIND_AUTO_CREATE for

the third parameter, to have our service automatically created when we bind to it.

Okay, let's get back to that service connection.

Binding and unbinding don't happen immediately.

The service connection is what we used to tell us,

when we're successfully connected and also when we've been disconnected.

When we call bindService, Android starts building a connection between our activity

and our service and when that connection is finally established,

Android will call the onService connected method of our service connection that we

provide as a parameter And if we ever get disconnected from our service

Android will let us know why calling the onServiceDisconnected method.

In addition to binding, we'll also need to use our service connection when we

unbind and the onStop method.

So if we need our service connection and onStart and

onStop, we'll need to create it as a field.

At the top of our class below our buttons, let's add a field for

our service connection, private ServiceConnection,

mService connection.

We still need to override the onService connected and

the onService disconnected methods of our service connection.

We could create our own class that implements service connection,

override those two methods, and then create a new instance of that class

Or we could just use an anonymous class.

If you've never used anonymous classes before, you're lying.

There's one right here.

An anonymous class is pretty much just a way to extend a class

without having to create a whole new class.

It's a way for us to add functionality to an object

without needing to create a new type of object.

Let's set our ServiceConnection to be = to a new anonymous ServiceConnection class.

So = new ServiceConnection.

Hit enter and there we go.

Back in the on start method let's pass on our new ServiceConnection field as

the second parameter to bind service.

And an onStop below the call to super, let's call the unbindService method.

And, as promised, it takes a service connection parameter.

Let's pass that in.

We're almost done.

But unfortunately, unbindService can throw an error if the service isn't bound.

One way this can happen is if our call to bind the service

wasn't successful in the first place.

If we didn't bind to our service, how can we expect to unbind from it?

We'll fix this by adding a boolean field named mBound to track whether or

not we are bound to the service.

Below our key declaration, Let's

add this new field private boolean mBound.

And let's set it = false.

Now, we need to update our inbound variable when our service is bound and

when it's unbound.

But how can we tell when our service is bound.

That's right!

The onServiceConnected method of our service connection.

And when our services unbound or

disconnected, the onServiceDisconnected method will be called.

So when onServiceConnected, let set mBound = to true and

then onServiceDisconnected Let's set mBound equal to false.

Last but not least, let's make sure we're only calling

unbind service if our service is actually bound, so

if mBound And add the other bracket at the bottom.

Then right below onbindService, let's set mBound to false.

On service disconnected is only called when something unexpected happens.

So calling unbind a service won't result in a call to on service disconnected,

which is why we're responsible for

updating mBound after calling unbind service.

We're almost done binding to our service.

Can you hear the music yet, me neither, but

I think we might hear some in this next video.