Información

Concepto

Un servicio es un componente que puede realizar operaciones de larga ejecución en segundo plano y que no proporciona una interfaz de usuario.

Funcionalidad

• Continua ejecutándose en segundo plano aunque el usuario cambie a otra aplicación.
• Un componente puede enlazarse con un servicio para interactuar con él e incluso realizar una comunicación entre procesos.

Estados

Servicio Iniciados

• Se inicia llamando a startService().
• Puede ejecutarse en segundo plano de manera indefinida, incluso si se destruye el componente que lo inició.
• Un servicio iniciado realiza una sola operación y no devuelve un resultado al emisor.

Servicio Enlazados

• Cuando se vincula a él llamando a bindService().
• Ofrece una interfaz cliente-servidor que permite que los componentes interactúen con el servicio.
• Un servicio de enlace se ejecuta solamente mientras otro componente de aplicación está enlazado con él.

Servicios Mixtos

• Puede iniciarse (para ejecutarse de manera indefinida) y también permitir los enlaces.
• Solo depende de que implementes un par de métodos de callback: onStartCommand( ) para permitir que los componentes lo inicien, y onBind( ) para permitir los enlaces.

Conceptos

Básicos

onStartComand( )

• El sistema llama a este método cuando otro componente, como una actividad, solicita que se inicie el servicio, llamando a startService().

onBind( )

• El sistema llama a este método cuando otro componente desea enlazarse con el servicio.
• Se debe proporcionar una interfaz que los clientes utilicen para comunicarse con el servicio, devolviendo una IBinder.
• Si no se desea permitir los enlaces, debe devolver NULL.

onCreate( )

• El sistema llama a este método cuando se crea el servicio por primera vez, para realizar los procedimientos de configuración por única vez.
• Antes de llamar a onStartCommand( ) o onBind( ).

onDestroy( )

• El sistema llama a este método cuando el servicio ya no se utiliza y se lo está destruyendo.

• Se usa para limpiar recursos como subprocesos, escuchas (listeners) registrados, receptores.

Declaración en el

manifesto

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService"/>
      ...
  </application>
</manifest>

Extensión de la

clase <IntentService>

Uso

En la mayoría de los servicios iniciados no se necesita manejar múltiples solicitudes simultáneamente (lo que, en realidad, puede ser un escenario peligroso de subprocesos múltiples).

public class HelloIntentService extends IntentService {

  /**
   * A constructor is required, and must call the super IntentService(String)
   * constructor with a name for the worker thread.
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }

  /**
   * The IntentService calls this method from the default worker thread with
   * the intent that started the service. When this method returns, IntentService
   * stops the service, as appropriate.
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // Normally we would do some work here, like download a file.
      // For our sample, we just sleep for 5 seconds.
      try {
          Thread.sleep(5000);
      } catch (InterruptedException e) {
          // Restore interrupt status.
          Thread.currentThread().interrupt();
      }
  }
}

Extensión de la

clase <Service>

Uso

Si se necesita que el servicio realice varios subprocesos (en lugar de procesar las solicitudes de inicio a través de una cola de trabajo), se puede extender la clase Service para manejar cada intento.

public class HelloService extends Service {
  private Looper mServiceLooper;
  private ServiceHandler mServiceHandler;

  // Handler that receives messages from the thread
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // Normally we would do some work here, like download a file.
          // For our sample, we just sleep for 5 seconds.
          try {
              Thread.sleep(5000);
          } catch (InterruptedException e) {
              // Restore interrupt status.
              Thread.currentThread().interrupt();
          }
          // Stop the service using the startId, so that we don't stop
          // the service in the middle of handling another job
          stopSelf(msg.arg1);
      }
  }

  @Override
  public void onCreate() {
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();

      Message msg = mServiceHandler.obtainMessage();
      msg.arg1 = startId;
      mServiceHandler.sendMessage(msg);

      // If we get killed, after returning from here, restart
      return START_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent)
  {
      // We don't provide binding, so return null
      return null;
  }

  @Override
  public void onDestroy() 
  {
       Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
  }
 }

Inicio de un

Servicio

Inicio de un servicio

Se puede iniciar un servicio desde una actividad u otro componente de la aplicación pasando un Intent (especifica que el servicio se inicie) a startService().

Detener un

Servicio

Detener un servicio

Una vez que se solicita la detención con stopSelf() o stopService(), el sistema destruye el servicio lo más pronto posible.

Ciclo de Vida

Servicio de Inicio

• Se crea cuando otro componente llama a startService().
• Se ejecuta de forma indefinida.
• Se debe detener a sí mismo llamando a stopSelf().
• Otro componente también puede detener el servicio llamando a stopService().

Servicio de Enlace

• Se crea cuando otro componente (un cliente) llama a bindService().
• El cliente puede cerrar la conexión llamando a unbindService().
• Se pueden enlazar varios clientes al mismo servicio, y cuando todos ellos se desenlazan, el sistema destruye el servicio (el servicio no necesita detenerse a sí mismo).

Ciclo de vida del servicio