Preview
Video Player
00:00
00:00
Binding Initiated
7:40In this video we setup our app to start the binding process. We’ll see where we bind, where we unbind, and we’ll learn about ServiceConnections!
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