CODEWITHSUNDEEP
androidandroid-intentandroid-serviceandroid-broadcastreceiver
CROSP
CROSP

Reputation: 4617

Android Bound Service vs Started Service for music app

I am trying to dive deep into service architecture.
Just for testing purpose I am creating music app.
Without doubts music should be played in service, but what kind of communication to use ? As far as I know service can be bound or started (or both at the same time)

Firstly, I need to play/stop/pause/set source...
Secondly, I need to notify UI if music player is opened about events like progress, buffering...

Here my thoughts about this.
I think about mixing bound and started service.

As far as song can be set only from UI as well as paused/played/stopped/seek I choose communication with service from UI using binder. (Bound service inside activity and get binder back to communicate with service)

Notifications like track completed, next track , current track position coming from the service. I decided to use Broadcast receiver to send such notifications, because it can be multiple interested components.

So my question are

  1. What is the best choice of communication (bound or broadcast) for music player service ?
  2. How does System knows what kind of service is ? I mean that even if the service is bound I need to call startService method at first and than bind it. Does it mean that if even one bindService method was called it is considered as bound service and it would be killed when unbind method is called ?
  3. Does LocalBroadcastManager make sense in communication with service ? As far as LocalBroadcastManager is local for each app, why not to use bound service than ? Global broadcast makes sense in case other apps are interested in events.

Please help to understand this mechanism.

Upvotes: 1

Views: 1457

Answers (2)

Damanpreet Singh
Damanpreet Singh

Reputation: 726

  1. Best choice of communication is using both LocalBroadcasts as well as Binder methods as per your requirement. If you want to do something in service from your bound component like activity then you should use binders. If you need to send result back to application you should use LocalBroadcast.

There is one more option available to use messaging. In this case both activity and service use same ibinder hence two way communication is easy. You can send message from activity to service and service to your activity

  1. In this point you are wrong about starting bound service. You don't need to call startservice in this case. Just a call of bindservice method is required.

    bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);

you can bind multiple components to this service. When all of them are unbound then service will be stopped.

  1. Yes LocalBroadcastmanagers make sense. Lets say you want to broadcast something in your app. There are 4-5 components that you want to update.How will you achieve this. Hence the use of localbroadcasts is a good feature.

For example lets say there are two services starting from different activities and second service starts its work when first service has done its work. So, only way to achieve this is send a broadcast and second service will be registering for this broadcast. Hence it will receive it.

Upvotes: 1

G. Blake Meike
G. Blake Meike

Reputation: 6715

Yeah. Services are pretty hard to understand.

There are some things that are easy. A bound service is always started with a bindService method. A started service is always started with a startService method. You do not need to start a bound service, or bind a started service.

A lot of what follows is gross generalization...

Started Service

A started service is nearly useless, unless it is an IntentService. IntentServices are pretty good tools for running asynchronous tasks. You send them a small bundle of parameters and they go off and do whatever those parameters indicate. They are like void methods in that one expects to use their side-effects, not a return value.

Bound Service

A bound service is harder to explain. Although the metaphor breaks down on careful examination, a bound service something like a singleton factory. It is, for instance, a way of providing a single object, with is single state, to all of the Activities in a application. Among its interesting features is that, as long as the service that provided the singleton object is bound, the hosting process is less likely to be killed off. Note that, the "singleton" object that the bound service provides has little to do with the service that provides it. Unbinding the service does not invalidate it.

Bound services are also the main means of doing inter-process communication, in Android.

What should you do?

Well, that's a pretty general question. Here's a thought. Putting your music player in a service makes a lot of sense. If the communication to it is mostly one way -- commands to the service -- there is a chance that you can do it with an IntentService. Until there's a specific reason to do something more complex, an IntentService has the advantage of being simpler.

Upvotes: 2

Related Questions