55

I would like to know if it is possible to have a service that is started with startService and then be able to also bind to that service and do some remote procedure calls? according to this:http://developer.android.com/guide/topics/fundamentals.html#servlife

the two services have different lifecycle so it's not possible,does anyone know about it?

BenMorel
  • 34,448
  • 50
  • 182
  • 322
maxsap
  • 2,971
  • 9
  • 44
  • 70

3 Answers3

98

I think hara's answer was a little confusing. What you describe is perfectly legitimate and in fact the only way to get the behavior you want. If you create a Service by binding to it, it will die when you unbind. So the only way to keep it around without activities binding to it is to start it with startService(). There is no conflict with lifecycles because it only applies to how the service is STARTED. So once it's started with startService(), it follows that lifecycle process. So you are free to bind and unbind to it as much as you wish and it will only die when you call stopService() or stopSelf().

Shubham Suryavanshi
  • 533
  • 9
  • 14
Falmarri
  • 47,727
  • 41
  • 151
  • 191
  • 4
    how do I bind to a service that was started with startService()? – user123321 Oct 19 '11 at 21:36
  • 3
    @musselwhizzle: this question is extremely old. If you have a question, start a new question thread. But there's no difference in the method in which you bind to a service that's already running. – Falmarri Oct 20 '11 at 00:26
  • 1
    You should also note that in order to have a service that is completely removed from the life cycle of an activity, start the service by passing the application's context. This means the service is tied to the life cycle of the application rather than activity. Also, look into START_STICKY. Returning start sticky along with the context of the application allows for your service to run removed from the lifecycle of the application and to restart itself in the event that it fails before completing its purpose. – superuserdo May 30 '15 at 17:35
  • @Falmarri what happens if i bind to a service in the foreground but the my activity goes into the background, am i still able to send messages from the bound service to the activity or only in foreground do the messages get passed ?can anyone help clear this up ? – j2emanue May 11 '19 at 06:03
19

Yes, You can start and bind (one or more times) the same service.

The following flowchart demonstrates how the lifecycle of a service is managed. The variable counter tracks the number of bound clients: enter image description here

Good example - music app. Explanation from Building a Media Browser Service official tutorial:

A service that is only bound (and not started) is destroyed when all of its clients unbind. If your UI activity disconnects at this point, the service is destroyed. This isn't a problem if you haven't played any music yet. However, when playback starts, the user probably expects to continue listening even after switching apps. You don't want to destroy the player when you unbind the UI to work with another app.

For this reason, you need to be sure that the service is started when it begins to play by calling startService(). A started service must be explicitly stopped, whether or not it's bound. This ensures that your player continues to perform even if the controlling UI activity unbinds.

To stop a started service, call Context.stopService() or stopSelf(). The system stops and destroys the service as soon as possible. However, if one or more clients are still bound to the service, the call to stop the service is delayed until all its clients unbind.

From Service ref:

A service can be both started and have connections bound to it. In such a case, the system will keep the service running as long as either it is started or there are one or more connections to it with the Context.BIND_AUTO_CREATE flag. Once neither of these situations hold, the service's onDestroy() method is called and the service is effectively terminated.

Yuliia Ashomok
  • 8,336
  • 2
  • 60
  • 69
13

If you start a service using startService(), then you should stop it using stopService().

There are two reasons that a service can be run by the system. If someone calls Context.startService() then the system will retrieve the service (creating it and calling its onCreate() method if needed) and then call its onStartCommand(Intent, int, int) method with the arguments supplied by the client. The service will at this point continue running until Context.stopService() or stopSelf() is called. Note that multiple calls to Context.startService() do not nest (though they do result in multiple corresponding calls to onStartCommand()), so no matter how many times it is started a service will be stopped once Context.stopService() or stopSelf() is called; however, services can use their stopSelf(int) method to ensure the service is not stopped until started intents have been processed.

You could bind to the service as many ServiceConnection as you want with bindService(), but pay attention to the flag you passed to it. If you pass 0 then if you call stopService() the service will stopped(i don't know exacltly what happens to you ServiceConnection). Otherwise if you want your service alive untill the ServiceConnection is binded to it then use BIND_AUTO_CREATE.

this is from stopService():

Request that a given application service be stopped. If the service is not running, nothing happens. Otherwise it is stopped. Note that calls to startService() are not counted -- this stops the service no matter how many times it was started.

Note that if a stopped service still has ServiceConnection objects bound to it with the BIND_AUTO_CREATE set, it will not be destroyed until all of these bindings are removed. See the Service documentation for more details on a service's lifecycle.

This function will throw SecurityException if you do not have permission to stop the given service.

i hope this helps..

Community
  • 1
  • 1
hara
  • 3,274
  • 4
  • 37
  • 55