[MUSIC]

So far, we've only seen one type of service started, but

remember there's two ways we can use a service.

In addition to starting a service we can also bind to a service.

Binding to a service is for

when we need to interact with our service in more ways than just starting it.

If we want to communicate with our service after starting it,

we'll need to buy into it.

If you're familiar with the client server model,

abound to service can be thought of as the server.

And the activity binding to that service can be thought of as the client.

A good example would be a service used for music playback.

Once the service is playing music,

there's all kinds of things we could want to tell it.

Like, play a song or skip to the next song.

Let's get started with bound services by adding the ability to play songs

to our music machine app.

First, let's create a new class for

music playing service and let's name it Player Service.

Then, let's make it extend to the service class and

use alt enter to implement the required on-bind method.

All right, before we go on, let's head over to our Android manifest and

declare our new service, use command or control D to duplicate

and change download intent service to player service, and we're done.

Let's also take this opportunity to get rid of some of the tabs we won't be

needing for a while.

Let's close all of our classes that start with download as well as the Android

manifest.

Now that we've got our service, let's take a minute to go over what we'll be doing.

The goal is for us to be able to play and pause a single song using a bound service.

Doing this with a service is what will allow us to have music playback in

the background, even when our activity is closed.

However, music playback is not the goal of this course.

So I won't be going into too much detail about it.

Sounds like we need a song.

That's why I put one in the teacher's notes below.

Go ahead and download it.

Then let's create a new resource directory named Raw where we can store our MP3 file.

Right click on the res directory, New, Android Resource Directory,

pick Raw as the resource type and then hit OK.

Then let's copy and paste the song into our new raw directory.

Copy.

Paste.

And now we'll be able to use this song in our code.

Cool.

Back in our player service class we'll be using a media player object

to handle playing and pausing our song.

Let's create a new field for our media

player by typing private media player, M player.

Now to initialize it.

We only need one media player, so where should we create it.

Well, to answer that question,

we need to have a better understanding of the service lifecycle.

Luckily, the lifecycle of a service is much simpler than that of an activity.

For a Started service [SOUND] we start with the call to startService [SOUND].

Then if our service hasn't been created yet, its onCreate [SOUND] method is

called followed by a call [SOUND] to onStartCommand.

And when a Started service is stopped, it's onDestroy method will be called.

For a bound service we start with a call to bindService, then if our service hasn't

been created yet it's onCreate method is called, followed by a call to onBind.

Once all the clients from our bound service have unbound

the onUnbind method will be called followed by one final call to onDestroy.

We can also have a service that is both started and bound, which means onStart

Command was called, and there's at least one client still bound to the service.

In this case on destroy won't be called until the service has been stopped and

all of the clients have on bound from the service, that wasn't so bad, right?

Back to the question, where should we initialize our media player?

Well, we only need one media player.

So, we probably shouldn't initialize end on bind.

Since on bind is called each time a client binds to our service.

Rather let's initialize it and

on create which is only called once during the life cycle of a service.

Let's add some space above on bind, and

use control O to open the over ride dialog.

Then let's override the on create method and

get on with an initializing our media player.

Let's get rid of this call to super.oncreate,

calling super isn't required for the service lifecycle.

Then let's type mPlayer = MediaPlayer.create,

pass in our context by using the this keyword, and pass in our resource ID for

the song, R.raw.jingle, voila!

In the next video will see how we can use this media player to play and

pause our song.