Red de conocimiento informático - Conocimiento informático - Cómo crear un servicio local para una aplicación de Android

Cómo crear un servicio local para una aplicación de Android

Este artículo detalla y demuestra el proceso de creación de estos dos servicios mediante código, aplicable a Android 2.3.3 y superiores.

1. Definir el archivo de manifiesto (AndroidManifest.xml)

2. Definir recursos de caracteres (strings.xml)

3. >

3.1.local_service_controller.xml

3.2.?Crear interfaz de inicio de servicio (LocalServiceActivities.java)

paquete my.android.test;

importar android .app.Activity;

importar android.content.ServiceConnection;

importar android.os.Bundle;

importar android.os.IBinder;

importar android.view.OnClickListener;

importar android.widget.Button;

importar android.widget.Toast;

/**

* Esta clase contiene dos tipos de clientes de servicio:

* Clientes para servicios de inicio: controladores

* Clientes para servicios vinculantes: vinculantes

*/

publicclass LocalServiceActivities {

/**

* La clase Controlador es el cliente que inicia el tipo de servicio. Contiene dos botones:

. p>

* iniciar: inicia el servicio cuando se hace clic en este botón.

*detener: Haga clic en este botón para finalizar el servicio.

*/

publicstaticclass El controlador extiende la actividad{

/**

* Este método se llama cuando la actividad se inicia por primera vez.

*/

@Override

protectedvoid onCreate(Bundle saveInstanceState){

super.onCreate(savedInstanceState);

// Complete el diseño

setContentView(R.layout.local_service_controller);

// Busque el botón Iniciar servicio en el diseño y configure el detector de eventos de clic.

Botón botón = (Button)findViewById(R.id.start);

button.setOnClickListener(mStartListener);

//Buscar terminación en el diseño Servir el botón y configurar un detector de eventos de clic.

botón = (Botón)findViewById(R.id.stop);

botón.setOnClickListener(mStopListener);

}

/**

* Implementación del detector de eventos de clic para el botón de inicio.

*/

OnClickListener privado mStartListener = new OnClickListener(){

publicvoid onClick(View v){

// Iniciar servicio local Atender.

startService(new Intent(Controller.this, LocalService.class));

}

}

};

/**

* Implementación del detector de eventos de clic para el botón de parada.

*/

OnClickListener privado mStopListener = new OnClickListener(){

publicvoid onClick(View v){

// Terminar LocalService ¡Atender! .

stopService(new Intent(Controller.this, LocalService.class));

}

};

}

/****************************** ************* * ******************

* La siguiente es la implementación del cliente de servicio vinculante

******* * ************************************************* ** *****/

/**

* La clase Binding es el cliente del servicio de tipo vinculante, que contiene dos botones:

* Vinculación: haga clic Cuando se hace clic en este botón, se llamará al método bindService() para vincular e iniciar el servicio;

* Desvinculación: cuando se hace clic en este botón, se llamará al método unbindService() para desvincular y finalizar el servicio.

*/

publicstaticclass El enlace extiende la actividad{

// Se utiliza para guardar el estado de enlace del servicio, verdadero: enlazado, falso: no enlazado

privatebooleanmIsBound;

* Vincular e iniciar el servicio Este método se llamará cuando se haga clic en el botón de vinculación.

*/

void doBindService(){

// Vincula e inicia el servicio.

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

mIsBound = true;

}< /p

/**

* Desvincular el servicio. Este método se llamará cuando se haga clic en el botón de desvincular.

*/

void doUnbindService(){

// Si el servicio está vinculado, desvincúlelo.

if(mIsBound){

unbindService(mConnection);

mIsBound = false;

}

}

/**

* Cuando se destruye la actividad, llame al método de desvinculación para desvincular el servicio cuando se destruye la actividad.

*/

@Override

protectedvoid onDestroy(){

super.onDestroy();

//Desvincular el servicio.

doUnbindService();

}

/**

* Implementación de la interfaz de escucha de eventos de clic para vincular botones.

*/

OnClickListener privado mBindListener = new OnClickListener(){

publicvoid onClick(View v){

/// Enlazar Definir e iniciar el servicio.

doBindService();

}

};

/**

* Botón de desvincular Evento de clic Implementación de la interfaz de escucha.

*/

OnClickListener privado mUnbindListener = new OnClickListener(){

publicvoid onClick(View v){

/// Descartar Servicios de encuadernación.

doUnbindService();

}

};

/**

* Este método está en Actividad llamada en el primer inicio.

*/

@Override

protectedvoid onCreate(Bundle saveInstanceState){

super.onCreate(savedInstanceState);

//fillActivity

setContentView(R.layout.local_service_b)id.unbind);

button.setOnClickListener(mUnbindListener);

} p>

}}

}

5. Crear servicio (LocalService.java)

paquete my.android.test;

importar android.app.Service;

importar android.content.Intent;

importar android.os.Looper;

importar android.os .Message ;

importar android.os.Process;

importar android.util.Log;

importar android.widget.Toast;

/**

* LocalService se basa en la clase de servicio de Android, que implementa el componente de servicio local de la aplicación.

* El servicio utiliza la clase HandlerThread para crear su propio hilo y bucle de mensajes.

* Por lo tanto, no habrá procesamiento a largo plazo en el servicio que bloquee la actualización de la interfaz y afecte. la experiencia del usuario.

*/

publicclass LocalService extiende el servicio {

// Se utiliza para guardar el propio objeto de bucle de mensajes del servicio Looper

private Looper mServiceLooper ;

// Se utiliza para guardar instancias de objetos de la clase interna ServiceHandler, que hereda de la clase de controlador de Android

// Se utiliza para procesar mensajes enviados al servicio.

private ServiceHandler mServiceHandler;

/**

* Esta clase se utiliza para proporcionar objetos vinculantes al cliente, porque el servicio en este ejemplo no es el igual que el cliente Se ejecuta en el mismo

* proceso principal, por lo que no necesita lidiar con la comunicación entre procesos (IPC)

*/**

publicclass LocalBinder extiende Binder{

LocalService getService(){

// Devuelve una instancia de este servicio.

return LocalService.this;

}

}

/**

* El sistema Esto Se llama al método al crear el servicio.

* Los componentes del servicio de Android deben anular este método

*/

@Override

publicvoid onCreate(){

//Crea un objeto de hilo e inicia el hilo.

HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);

thread.start()

/Obtener el objeto de bucle de mensajes del hilo<; /p>

mServiceLooper = thread.getLooper();

/ Utilice el objeto de bucle de mensajes del hilo para crear un objeto de procesamiento de mensajes.

mServiceHandler = new ServiceHandler(mServiceLooper);

}

/**

* Los servicios de inicio deben ejecutar este método cada vez. Cada vez que el cliente llama al método startService(),

* el sistema llamará a este método.

* @param intent: Es el objeto Intent pasado al método startService().

* @param flags: Datos adicionales sobre la solicitud de inicio, pueden ser: 0, START_FLAG_REDELIVERY o START_FLAG_RETRY.

* @param startId: un número entero único que representa una solicitud específica para el método stopSelfResult(int).

*/

@Override

publicint onStartCommand(Intent intent, int flags, int startId){

Log.i(" LocalService", "ID de estrella recibida" + startId + ":" + intent);

//Muestra el mensaje de aviso de que el servicio se está iniciando

Toast.makeText(this, " El servicio se está iniciando Start");

//Muestra el mensaje de aviso de que el servicio se está iniciando

Toast.makeText(this, "servicio iniciando", Toast.LENGTH_SHORT).show ();

// Obtiene el objeto de mensaje que se pasará al bucle de mensajes del servicio.

Message msg = mServiceHandler.containMessage();

//Inicializa las variables miembro del objeto Mensaje.

msg.arg1 = startId;

msg.obj = "Procesamiento de mensajes...".+ startId;

//Al hilo de servicio El mensaje Bucle que envía mensajes.

mServiceHandler.sendMessage(msg);

returnSTART_STICKY;

}

/**

* Este El método debe sobrecargarse y llamarse cuando finaliza el servicio para limpiar los recursos ocupados por el servicio.

*/

@Override

publicvoid onDestroy(){

Salga del bucle de mensajes del hilo de servicio.

mServiceLooper.quit();

/ Muestra el mensaje de que el servicio ha cerrado.

Toast.makeText(this, R.string.local_service_stopped, Toast.LENGTH_SHORT).show();

}

/**

* Los servicios vinculados deben anular este método, los servicios iniciados también pueden anular este método siempre que devuelvan un valor nulo.

*/

@Override

public IBinder onBind(Intent intent){

// Devuelve una instancia de este objeto de servicio.

returnmBinder;

}

privatefinal IBinder mBinder = new LocalBinder();

/**

*Esta clase hereda de la clase de controlador de Android y proporciona un bucle de mensajes para que los hilos envíen y procesen mensajes.

*/

privatefinalclass ServiceHandler extiende Handler{

// La creación de instancias de clase debe pasar el objeto de bucle de mensajes del hilo de servicio

public ServiceHandler (Looper looper){

super(looper);

}

/**

* Anula el handleMessage( de la clase controladora), que se llama cuando el bucle de mensajes del hilo de servicio recibe un mensaje enviado desde el exterior

*. Este ejemplo simplemente indica al usuario que el mensaje ha sido procesado.

*/

@Override

publicvoid handleMessage(Mensaje de mensaje){

long endTime = System.currentTimeMillis() + 5 * 1000;

mientras (System.currentTimeMillis()

sincronizado(esto){

intenta{

esperar( endTime - System.currentTimeMillis())currentTimeMillis());

CharSequence ? cs = msg.obj.toString();

Toast.makeText(LocalService.this, cs, Toast .LENGTH_SHORT).show();

/

LocalService.this.stopSelf();

}

}

}

}