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(); } } } }