Introducción de esta sección
Bien, en las tres secciones anteriores hemos estudiado y aprendido sobre Activity en Android, ¡creo que todos habéis obtenido muchos beneficios! En esta sección continuamos aprendiendo el segundo componente de Android: Service (servicio). Bien, sin más preámbulos, ¡comencemos con el contenido de esta sección!
1. Conceptos relacionados con los hilos
Antes de empezar a aprender Service, primero comprendamos algunos conceptos sobre los hilos.
1) Conceptos relacionados:
- Programa: para completar una tarea específica, un conjunto de instrucciones escritas en algún lenguaje (un conjunto decódigo estático)
- Proceso:programa en ejecución, unaunidad independiente, el sistema operativo asignará un espacio de memoria para cada proceso. La ejecución dinámica secuencial de un programa experimenta el proceso completo de carga, ejecución y finalización del código.
- Hilo: es una unidad de ejecución más pequeña que un proceso; cada proceso puede tener múltiples hilos,El hilodebe colocarse en unprocesopara poder ejecutarse,el hilo es gestionado por el programa, mientras queel proceso es programado por el sistema.
- Comprensión del multihilo:Paraleloejecutar múltiples instrucciones; elintervalo de tiempo de CPUse asigna a cada hilo según el algoritmo de programación. En realidad, espor tiempo compartidose ejecuta simultáneamente, pero el tiempo de conmutación es muy corto, ¡el usuario siente que es 'al mismo tiempo'!
2) Ciclo de vida del hilo:

3) Tres formas de crear hilos:
- Heredar de la clase Thread
- Implementar la interfaz Runnable
- Implementar la interfaz CallableSi se usa un hilo creado con la opción 2, se puede iniciar directamente así:
new Thread(myThread).start();Pero la mayoría de las veces preferimos usar clases anónimas, es decir, la siguiente forma de escritura:new Thread(new Runnable(){ public void run(); }).start();
2. Diferencias entre Service y el hilo Thread
En realidad, no tienen mucha relación, pero muchos amigos suelen confundir estos dos conceptos. Thread es un hilo, la unidad más pequeña de ejecución del programa y la unidad básica de asignación de CPU. Service, en cambio, es un componente que Android proporciona para permitir permanecer en segundo plano durante mucho tiempo. El uso más común es hacer operaciones de sondeo, o querer hacer algo en segundo plano, como descargas y actualizaciones en segundo plano. ¡Recuerda no confundir estos dos conceptos!
3. Diagrama del ciclo de vida de Service

4. Análisis del ciclo de vida
Bien, a partir del ciclo de vida de la figura anterior, podemos saber que hay dos formas de usar Service en Android:
1)Iniciar Service con StartService()
2)Iniciar Service con BindService()
PD: Hay otra forma: después de iniciar el Service, vincularlo.
1) Explicación detallada de los métodos relacionados:
- onCreate(): Este método se llama inmediatamente después de que el Service se crea por primera vez; en todo el ciclo de vida solo se llamará una vez.
- onDestory(): Cuando el Service se cierra, se llamará a este método; este método solo se llamará una vez.
- onStartCommand(intent,flag,startId): En versiones anteriores era onStart(intent, startId). Cuando el cliente llama al método startService(Intent), se llamará a este método. Se puede llamar a StartService varias veces, pero no se creará un nuevo objeto Service, sino que se seguirá reutilizando el objeto Service creado anteriormente, y se seguirá llamando al método onStartCommand().
- IBinder onOnbind(intent): Este es un método que todos los Service deben implementar. Este método devuelve un objeto IBinder, y la aplicación se comunica con el componente Service a través de este objeto.
- onUnbind(intent): Este método se llamará cuando todos los clientes vinculados a este Service se desconecten.
2) Iniciar Service con StartService
①Al iniciarse por primera vez, se crea una instancia de Service y se llaman sucesivamente a onCreate() y onStartCommand(). En este momento, el Service entra en estado de ejecución. Si se llama a StartService nuevamente para iniciar el Service, no se creará un nuevo objeto Service; el sistema reutilizará directamente el objeto Service creado anteriormente y llamará a su método onStartCommand().
②Pero este tipo de Service no tiene una conexión necesaria con su llamador; es decir, cuando el llamador termina su propio ciclo de vida, siempre que no se llame a stopService, el Service continuará ejecutándose.
③No importa cuántas veces se haya iniciado el Service, solo se necesita llamar una vez a StopService para detenerlo.
3) Iniciar Service con BindService
①Cuando se usa bindService por primera vez para vincular un Service, el sistema crea una instancia de Service y llama a sus métodos onCreate() y onBind(). Luego, el llamador puede interactuar con el Service a través de IBinder. A partir de entonces, si se vuelve a usar bindService para vincular el Service, el sistema no creará una nueva instancia de Service ni volverá a llamar al método onBind(), sino que solo pasará el objeto IBinder directamente a los demás clientes que se agreguen más tarde.
②Si desvinculamos el servicio, solo necesitamos llamar a unbindService(). En este momento se llamarán a los métodos onUnbind y onDestory. Este es el caso de un solo cliente; si son varios clientes los que están vinculados al mismo Service, la situación es la siguiente: cuando un cliente completa su interacción con el servicio, llama al método unbindService() para desvincularse. Cuando todos los clientes se han desvinculado del servicio, el sistema destruirá el servicio. (A menos que el servicio también haya sido iniciado mediante el método startService()).
③Además, a diferencia de la situación anterior, en el modo bindService, el Service está interrelacionado con el llamador. Se puede entender como 'saltamontes atados a la misma cuerda': si uno muere, todos mueren. Después de bindService, una vez que el llamador se destruye, el Service también termina inmediatamente.
Análisis del bindService de Context al invocar un Service mediante BindServicebindService(Intent Service,ServiceConnection conn,int flags)
service: a través de este intent se especifica el Service que se va a iniciar
conn: objeto ServiceConnection, utilizado para escuchar el estado de conexión entre el visitante y el Service. Cuando la conexión es exitosa, se llama al método onServiceConnected(ComponentName, IBinder) de este objeto; si el host donde se encuentra el Service termina debido a una terminación anormal u otras razones, lo que provoca que el Service y el visitante se desconecten, se llamaonServiceDisconnectedal método (CompanentName); si se desconecta activamente medianteunBindService()el método de desconexión, no se llamará a los métodos anteriores.
flags:Especifica si se crea automáticamente el Service al vincular(si el Service aún no se ha creado). El parámetro puede ser 0 (no crear automáticamente) o BIND_AUTO_CREATE (crear automáticamente).
4) Vincular con bindService después de iniciar Service con StartService
Si un Service ya ha sido iniciado por un cliente mediante StartService(), y luego otro cliente llama a bindService() para vincularse a ese Service, después llama a unbindService() para desvincularse y finalmente vuelve a llamar a bindService() para vincularse al Service, los métodos del ciclo de vida que se activan en este momento son los siguientes:
onCreate( )->onStartCommand( )->onBind( )->onUnbind( )->onRebind( )
PS:La premisa es: ¡¡¡el método onUnbind() devuelve true!!! Quizás algunos lectores tengan dudas aquí: después de llamar a unbindService, ¿no debería el Service llamar al método onDistory()? En realidad, esto se debe a que este Service fue iniciado por nuestro StartService, por lo que si llamas al método onUnbind() para cancelar la vinculación, el Service tampoco terminará.
Conclusión:Si usamos bindService para vincular un Service ya iniciado, ¡¡¡nota que es un Service ya iniciado!!! El sistema solo pasa el objeto IBinder interno del Service a la Activity, no vincula el ciclo de vida del Service con la Activity, por lo tanto, al llamar al método unBindService( ) para cancelar la vinculación, ¡el Service tampoco será destruido!
5. Verificación del ciclo de vida
A continuación, escribimos código para verificar el ciclo de vida:
1) Verificar el orden de llamadas al iniciar Service con StartService
Primero personalizamos un Service, sobrescribimos los métodos relevantes y el usuario imprime la verificación en logcat:
TestService1.java
public class TestService1 extends Service {
private final String TAG = "TestService1";
//必须要实现的方法
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "onBind方法被调用!");
return null;
}
//Service被创建时调用
@Override
public void onCreate() {
Log.i(TAG, "onCreate方法被调用!");
super.onCreate();
}
//Service被启动时调用
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG, "onStartCommand方法被调用!");
return super.onStartCommand(intent, flags, startId);
}
//Service被关闭之前回调
@Override
public void onDestroy() {
Log.i(TAG, "onDestory方法被调用!");
super.onDestroy();
}
}
AndroidManifest.xml completa el registro del Service
<!-- 配置Service组件,同时配置一个action -->
<service android:name=".TestService1">
<intent-filter>
<action android:name="com.jay.example.service.TEST_SERVICE1"/>
</intent-filter>
</service>
¡Luego viene un archivo de diseño simple con dos botones, y finalmente la escritura de MainActivity; en los eventos de clic de los botones se llaman respectivamente a startService( ) y stopService( )!
public class MainActivity extends Activity {
private Button start;
private Button stop;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
start = (Button) findViewById(R.id.btnstart);
stop = (Button) findViewById(R.id.btnstop);
//创建启动Service的Intent,以及Intent属性
final Intent intent = new Intent();
intent.setAction("com.jay.example.service.TEST_SERVICE1");
//为两个按钮设置点击事件,分别是启动与停止service
start.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startService(intent);
}
});
stop.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
stopService(intent);
}
});
}
}
Captura de pantalla de ejecución:

Haz clic en Iniciar servicio:

Después de comer, sin nada que hacer, hago clic varias veces:

Finalmente, haz clic en Detener servicio:

Análisis de resultados:
A partir de los resultados de ejecución anteriores podemos verificar lo explicado en nuestro diagrama del ciclo de vida: encontramos que el método onBind() no es llamado; además, al hacer clic varias veces para iniciar el Service, ¡solo se llama repetidamente al método onStartCommand! ¡No importa cuántas veces iniciemos el Service, un solo stopService detendrá el Service!
2) Verificar el orden al iniciar Service con BindService:
Antes de empezar a escribir el código, primero tenemos que entender algunas cosas: en primer lugar, el método bindService de Context que se muestra debajo del primer diagrama grande:
- Objeto ServiceConnection: supervisa la conexión entre el cliente y el Service. Si la conexión es exitosa, se llama a onServiceConnected(). Si la conexión se termina de manera anormal u otras razones causan que el Service y el cliente se desconecten, se llama al método onServiceDisconnected. ¡Llamar a unBindService() no llamará a ese método!
- En el método onServiceConnected hay un objeto IBinder, que permite la comunicación con el Service vinculado. Al desarrollar la clase Service, por defecto debemos implementar el método IBinder onBind(); el objeto IBinder devuelto por este método se pasa al parámetro onServiceConnected del objeto ServiceConnection, y aquí podemos comunicarnos con el Service a través de este IBinder.
Resumen:
Step 1:En el Service personalizado, heredar de Binder para implementar nuestro propio objeto IBinder
Step 2:Devolver nuestro propio objeto IBinder mediante el método onBind( )
Step 3:En la clase que vincula este Service, definir un objeto ServiceConnection y sobrescribir dos métodos: onServiceConnected y onDisconnected. ¡Luego simplemente leemos los parámetros pasados por el IBinder!
Muy bien, a continuación escribimos código para verificar. Aquí definimos un Service para cronometrar, y luego demostramos el uso de BindService y el flujo de llamadas de los métodos. ¡El código es bastante simple, así que no lo explicaré!
TestService2.java:
public class TestService2 extends Service {
private final String TAG = "TestService2";
private int count;
private boolean quit;
//定义onBinder方法所返回的对象
private MyBinder binder = new MyBinder();
public class MyBinder extends Binder
{
public int getCount()
{
return count;
}
}
//必须实现的方法,绑定改Service时回调该方法
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, "onBind方法被调用!");
return binder;
}
//Service被创建时回调
@Override
public void onCreate() {
super.onCreate();
Log.i(TAG, "onCreate方法被调用!");
//创建一个线程动态地修改count的值
new Thread()
{
public void run()
{
while(!quit)
{
try
{
Thread.sleep(1000);
}catch(InterruptedException e){e.printStackTrace();}
count++;
}
};
}.start();
}
//Service断开连接时回调
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "onUnbind方法被调用!");
return true;
}
//Service被关闭前回调
@Override
public void onDestroy() {
super.onDestroy();
this.quit = true;
Log.i(TAG, "onDestroyed方法被调用!");
}
@Override
public void onRebind(Intent intent) {
Log.i(TAG, "onRebind方法被调用!");
super.onRebind(intent);
}
}
Registrar el componente Service en AndroidManifest.xml:
<service android:name=".TestService2" android:exported="false">
<intent-filter>
<action android:name="com.jay.example.service.TEST_SERVICE2"/>
</intent-filter>
</service>
MainActivity.java:
public class MainActivity extends Activity {
private Button btnbind;
private Button btncancel;
private Button btnstatus;
//保持所启动的Service的IBinder对象,同时定义一个ServiceConnection对象
TestService2.MyBinder binder;
private ServiceConnection conn = new ServiceConnection() {
//Activity与Service断开连接时回调该方法
@Override
public void onServiceDisconnected(ComponentName name) {
System.out.println("------Service DisConnected-------");
}
//Activity与Service连接成功时回调该方法
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
System.out.println("------Service Connected-------");
binder = (TestService2.MyBinder) service;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnbind = (Button) findViewById(R.id.btnbind);
btncancel = (Button) findViewById(R.id.btncancel);
btnstatus = (Button) findViewById(R.id.btnstatus);
final Intent intent = new Intent();
intent.setAction("com.jay.example.service.TEST_SERVICE2");
btnbind.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//绑定service
bindService(intent, conn, Service.BIND_AUTO_CREATE);
}
});
btncancel.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//解除service绑定
unbindService(conn);
}
});
btnstatus.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(getApplicationContext(), "Service的count的值为:"
+ binder.getCount(), Toast.LENGTH_SHORT).show();
}
});
}
}
Captura de pantalla de ejecución:

Haz clic en Bloquear Service:

Continuar haciendo clic en Bloquear: no hay ningún cambio

Obtener el estado actual del Service:

Desvincular:

¡Si después de vincular cerramos directamente la Activity, se producirá un error, y luego se llamarán automáticamente a los métodos onUnbind y onDestory!
。。。

A partir de los resultados de ejecución anteriores se verifica lo que se muestra en el diagrama del ciclo de vida:
Al usar BindService para vincular el Service, se llaman secuencialmente a los métodos onCreate() y onBind(). Podemos devolver el objeto IBinder personalizado en el método onBind(). Luego se llama al método onServiceConnected() de ServiceConnection, en el cual se puede obtener el objeto IBinder para realizar operaciones relacionadas. Cuando el Service se desvincula, se llaman automáticamente a onUnbind y onDestroyed. Por supuesto, en el caso de múltiples clientes vinculados, solo después de desvincular todos se llamará a onDestoryed para su destrucción.