El servicio se ha visto muchas veces, y hoy traté de practicarlo y resumirlo yo mismo. Resumir principalmente el método de inicio del servicio (el mismo proceso y diferentes procesos), las características y la interacción (incluido AIDL)
Uno: hay dos formas de iniciar el servicio, una es startService y la otra es bindService
1. Crear un servicio
public class MyStartService1 extends Service {
int count=0;
Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case 100:
count+=1;
Log.e("TAG","MyStartService1正在执行:"+count);
sendEmptyMessageDelayed(100,3000);
break;
case 200:
break;
}
}
};
@Override
public void onCreate() {
super.onCreate();
Log.e("TAG", "MyStartSerice1--onCreate--当前进程："+getCurProcessName(this) );
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.e("TAG", "MyStartSerice1--onStartCommand-starttId:" + startId);
if (intent != null) {
String extra = intent.getStringExtra("extra");
Log.e("TAG", "MyStartSerice1--intent参数：" + extra);
} else {
Log.e("TAG", "MyStartSerice1--intent参数：null!!!");
}
handler.removeCallbacksAndMessages(null);
Message obtain = Message.obtain();
obtain.what=100;
handler.sendMessage(obtain);
return START_STICKY;
}
@Override
public void onDestroy() {
super.onDestroy();
handler.removeCallbacksAndMessages(null);
Log.e("TAG", "MyStartSerice1--onDestroy");
}
public String getCurProcessName(Context context) {
int pid = android.os.Process.myPid();
ActivityManager mActivityManager = (ActivityManager) context
.getSystemService(Context.ACTIVITY_SERVICE);
for (ActivityManager.RunningAppProcessInfo appProcess : mActivityManager
.getRunningAppProcesses()) {
if (appProcess.pid == pid) {
return appProcess.processName;
}
}
return "";
}
}2. Iniciar y detener métodos
En el mismo proceso: directamente startService
intentService = new Intent(TestActivity1.this, MyStartService1.class);
intentService.putExtra("extra","我是参数，test1");
startService(intentService);En diferentes procesos: debe abrirse por nombre de paquete, nombre de clase setComponent (nuevo ComponentName (nombre de paquete, nombre de clase))
intentService = new Intent();
intentService.putExtra("extra","test2参数");
intentService.setComponent(new ComponentName("com.example.liukang.mykuajincheng",MyStartService2.class.getName()));
startService(intentService);Cerrar el servicio: stopService(intentService)和stopSelf(startId)
stopService(intentService);Dos: inicio del ciclo de servicio:
onCreate-->onStartCommand-->onDestroy 如果是已经开启的startservice,无论startService多少次，都不会再去oncre,而是一直调用onStartCommand方法
Puede ser abierto por muchas actividades, o puede ser cerrado por stopService (intent) en cualquier Actividad.
El significado del valor de retorno de los tres tipos de Int devueltos en startCommand:
1. START_NOT_STICKY = 2 No se reinicia después de ser eliminado. Después de que se inicia el servicio, cuando el proceso en el que se encuentra el servicio se mata y actualmente no hay nuevos Intents esperando para ser enviados, no se crea ningún nuevo servicio y se marca como no iniciado hasta el siguiente explícito. iniciar llamada — startService ().
2. START_STICKY = 1 Reiniciar automáticamente después de ser asesinado, mantener el estado de inicio, no mantener el Intent, volver a llamar a onStartCommand, sin Intent nuevo, Intent vacío: después de matar y reiniciar, no continúe realizando la tarea anterior, puede aceptar la nueva tarea
3. START_REDELIVER_INTENT = 3 Si el servicio se mata de forma anormal después de ejecutar onStartCommand, el sistema reiniciará automáticamente el servicio y pasará el valor de Intent.
Características de startService:
1. Lo que abre es un servicio, y su prioridad es proceso en primer plano> proceso visible> proceso de servicio> proceso en segundo plano> proceso vacío, por lo que intentará sobrevivir en el caso de que los recursos sean insuficientes.
2. Cuando los recursos son insuficientes y el servicio se mata, se puede reiniciar cuando los recursos son abundantes, lo que se determina de acuerdo con el tipo de retorno de startCommmand ().
3. Inicie varias veces, solo ejecute onCreate () una vez, ejecute startCommand () varias veces
4. Cuando se inicia la interfaz del servicio, la clase Destroy () continuará ejecutándose y se puede terminar llamando a stopService (intent) en cualquier otra interfaz.
, Para algunas tareas de larga duración se pueden colocar en el servicio, como solicitudes de red como latido.
En segundo lugar, BindService vincula servicios, lo que es un punto a destacar, ya que implica interacciones que incluyen AIDL de proceso cruzado, que va desde el más superficial al más profundo.
Breve descripción: ciclo de vida onCreate () -> onBind () -> onUnbind () -> onDestroy ()
1. En el mismo proceso, primero cree Service1: onBind () devuelve un objeto Binder y reescribe varios métodos
paquete com.example.liukang.mykuajincheng.bindservice;
importar android.app.Service;
importar android.content.Intent;
importar android.content.ServiceConnection;
importar android.os.Binder;
importar android.os.Handler;
importar android.os.IBinder;
importar android.os.Message;
importar android.support.annotation.Nullable;
importar android.util.Log;
La clase pública MyBindService1 extiende Service {
int count = 0;
Handler handler = new Handler (new Handler.Callback () {
@Override
public boolean handleMessage (Mensaje msg) {
switch (msg.what) {
case 1000:
Log.e ("TAG", "MyBindService1 服务 开启 了 ：" + recuento);
contar + = 1;
handler.sendEmptyMessageDelayed (1000,3000);
descanso;
}
devuelve verdadero;
}
});
MyBinder1 myBinder1 = new MyBinder1 ();
class MyBinder1 extiende Binder implementa Iterface {
public MyBindService1 getService () {
return MyBindService1.this;
}
@Override
public void start () {
handler.sendEmptyMessage (1000);
}
@Override
public void stop () {
handler.removeCallbacksAndMessages (nulo);
}
@Anular
público String open (String ss) {
return "result =" + ss;
}
}
@Override
public void onCreate () {
super.onCreate ();
Log.e ("TAG", "MyBindService1: onCre");
} @Nullable
@Override
public IBinder onBind (Intent intent) {
Log.e ("TAG", "MyBindService1: onBind");
return myBinder1;
}
@Override
public boolean onUnbind (Intent intent) {
Log.e ("TAG", "MyBindService1: onUnbind");
@Override
public void unbindService (ServiceConnection conn) {
}
super.unbindService (conn);
}
@Override
public void onDestroy () {
super.onDestroy ();
Log.e ("TAG", "MyBindService1: onDestroy");
handler.removeCallbacksAndMessages (nulo);
}
interfaz Iterface {
void start ();
parada vacía ();
Cadena abierta (Cadena ss);
}
}
2. Iniciar
Primero cree un objeto ServiceConnection, este objeto puede obtener el objeto Binder, obtenerlo, puede operar el método en el servicio, deje que el servicio ejecute el comando que controlamos
Inicie el servicio a través de bindService (intent, myConnection, BIND_AUTO_CREATE); de la siguiente manera:
De esta manera, el servicio está vinculado y el objeto proxy Binder del servicio se mantiene en el método onServiceConnected () para realizar el control de las tareas en el servicio.
Finalizar servicio: cuando se destruye la actividad del host que inició este servicio, o se llama a unbindService (myConnection), puede finalizar el servicio.
Nota:
2. Lo anterior solo realiza comunicación unidireccional, es decir, Actividad -> Servicio emite instrucciones. Si desea lograr una comunicación interactiva, debe usar Messenger. Además, también se puede usar en aplicaciones de procesos cruzados. Diferentes procesos en la misma aplicación o procesos entre diferentes aplicaciones pueden comunicarse entre sí.
Los principales pasos para crear un servicio:
Primero cree el objeto controlador y construya el objeto Messenge
Luego regrese a un agente en onBind (), que es diferente del agente anterior, que se obtiene del mensajero
Entonces mira como empezar
Primero cree el objeto ServiceConnection y luego obtenga el objeto Messenger en el servicio a través del objeto IBinder
bindService (intent, myConnection, BIND_AUTO_CREATE) vincula el servicio
El método para llamar al servicio en Actividad: crear un mensaje y luego enviarlo al servicio a través del objeto Messenge en el Servicio obtenido, Messenger.send (msg)
En este momento, el manejador en el Messenger en el servicio recibirá el mensaje enviado desde la Actividad en este momento, y podrá procesarlo según los parámetros o identificadores para realizar la comunicación de Actividad -> Servicio.
¿Cómo hacer que el servicio se comunique con la actividad? Podemos adivinar: si la Actividad también tiene un objeto Messenge, y deja que el Servicio lo retenga, ¿no es lo mismo que enviar mensajes a la Actividad a través de Messenger.send (msg) para lograr la comunicación?
Primero, cree un objeto controlador en Activity y utilícelo para construir un objeto Messenge, de la siguiente manera:
Luego, coloque el objeto cMessenger anterior en el paquete de mensajes msg, de modo que el Mensaje enviado al servicio de servicio contenga el objeto Messenge de la Actividad, de la siguiente manera:
Finalmente, luego de recibir el mensaje en el Servicio, saque el Mensaje en la Actividad, y ahora sostenga el objeto cMessenge en la Actividad, y también puede enviar un mensaje a la Actividad, de la siguiente manera:
En este punto, BindService también se ha resuelto
3. Hablemos de la llamada de servicios remotos AIDL. Hablando intuitivamente, vinculamos un servicio remoto a través del archivo aidl. Después de tener éxito, podemos obtener un objeto proxy IMyAidlInterface y luego usar este objeto para llamar al método de servicio remoto. Tareas de procesamiento .
Servidor
1. Primero cree un archivo aidl en el servidor:
2. Luego compílelo:
3. Cree el servicio en el lado del servidor para implementar la interfaz aidl, de la siguiente manera:
Cliente
1. Copiamos el archivo aidl y lo colocamos en el cliente, el nombre del paquete debe ser el mismo, de la siguiente manera:
2. Finalmente, cree un objeto ServiceConnection y vincule el servicio.Cuando el enlace sea exitoso, se obtendrá el objeto IMyAidlInterface, y luego el método del servidor se puede operar de forma remota.
3. La convocatoria es la siguiente:
Para algunas aplicaciones grandes, algunas operaciones requieren que AIDL llame al inicio de sesión del servicio, y se puede usar la verificación y similares.
Básicamente está por aquí, es relativamente superficial, pero entiendo un poco que se puede encontrar al leer algunos proyectos a gran escala. Ja ja