Explain Android Service?

A service can be used in two ways:

• It can be started and allowed to run until someone stops it or it stops itself. In this mode, it's started by callingContext.startService() and stopped by calling Context.stopService(). It can stop itself by calling Service.stopSelf() orService.stopSelfResult(). Only one stopService() call is needed to stop the service, no matter how many timesstartService() was called. 
  
• It can be operated programmatically using an interface that it defines and exports. Clients establish a connection to the Service object and use that connection to call into the service. The connection is established by calling Context.bindService(), and is closed by calling Context.unbindService(). Multiple clients can bind to the same service. If the service has not already been launched, bindService() can optionally launch it. 
  
  
  The two modes are not entirely separate. You can bind to a service that was started with startService(). For example, a background music service could be started by calling startService() with an Intent object that identifies the music to play. Only later, possibly when the user wants to exercise some control over the player or get information about the current song, would an activity establish a connection to the service by calling bindService(). In cases like this, stopService() will not actually stop the service until the last binding is closed. 
  
  
  Like an activity, a service has lifecycle methods that you can implement to monitor changes in its state. But they are fewer than the activity methods — only three — and they are public, not protected:
  void onCreate() 
void onStart(Intent intent) 
void onDestroy()
  By implementing these methods, you can monitor two nested loops of the service's lifecycle:
  • The entire lifetime of a service happens between the time onCreate() is called and the time onDestroy() returns. Like an activity, a service does its initial setup in onCreate(), and releases all remaining resources in onDestroy(). For example, a music playback service could create the thread where the music will be played in onCreate(), and then stop the thread inonDestroy().
  • The active lifetime of a service begins with a call to onStart(). This method is handed the Intent object that was passed tostartService(). The music service would open the Intent to discover which music to play, and begin the playback.
    There's no equivalent callback for when the service stops — no onStop() method.
  The onCreate() and onDestroy() methods are called for all services, whether they're started by Context.startService() orContext.bindService(). However, onStart() is called only for services started by startService().
  
  
  If a service permits others to bind to it, there are additional callback methods for it to implement:
  IBinder onBind(Intent intent) 
boolean onUnbind(Intent intent) 
void onRebind(Intent intent)
  The onBind() callback is passed the Intent object that was passed to bindService and onUnbind() is handed the intent that was passed to unbindService(). If the service permits the binding, onBind() returns the communications channel that clients use to interact with the service. The onUnbind() method can ask for onRebind() to be called if a new client connects to the service. 
  
  
  The following diagram illustrates the callback methods for a service. Although, it separates services that are created viastartService from those created by bindService(), keep in mind that any service, no matter how it's started, can potentially allow clients to bind to it, so any service may receive onBind() and onUnbind() calls.
  
  
  Go for Service Lifecycle...............