Introducción a esta sección

En la sección anterior aprendimos el ciclo de vida de Service y las dos formas de iniciar un Service. En esta sección continuaremos profundizando en IntentService dentro de Service, y ejemplos de uso de Service: ¡la implementación de servicios en primer plano y sondeos!


1. Uso de IntentService

Después de la sección anterior, ya sabemos cómo definir e iniciar un Service. Sin embargo, si ponemos directamente el subproceso que consume tiempo en el método onStart() del Service, aunque se puede hacer, es muy fácil provocar la excepción ANR (Application Not Responding). Y la documentación oficial de Android tiene el siguiente párrafo al presentar Service:

Traducción directa:

1. Service no es un proceso separado; está en el mismo proceso que su aplicación.
2. Service no es un subproceso; esto significa que debemos evitar realizar operaciones que consumen tiempo en Service.

Por lo tanto, Android nos proporciona una alternativa para resolver el problema anterior, que es lo que se explicará a continuación.IntentServiceIntentService es una clase que hereda de Service y maneja solicitudes asíncronas. En IntentService hay un subproceso de trabajo para manejar operaciones que consumen tiempo; los registros de Intent de las solicitudes se agregan a una cola.

Flujo de trabajo:

El cliente inicia IntentService mediante startService(Intent); no necesitamos controlar IntentService manualmente. Cuando la tarea se completa, IntentService se detiene automáticamente. Puedes iniciar IntentService varias veces; cada operación que consume tiempo se ejecuta en el método de devolución de llamada onHandleIntent de IntentService en forma de cola de trabajo, y solo se ejecuta un subproceso de trabajo a la vez; ¡primero uno, luego el segundo, así!

A continuación, la demostración de código. La mayoría de los códigos en Internet comparan Service e IntentService, definen un tiempo de suspensión lo suficientemente largo para demostrar la excepción ANR de Service y luego muestran lo bueno que es IntentService. Aquí no demostraremos Service; los ejemplos en Internet definen un Service personalizado y luego llaman a Thread.sleep(20000) en el método onStart(), lo que provoca la excepción ANR. Si te interesa, puedes escribir código para probarlo. Aquí solo demostramos el uso de IntentService.

TestService3.java

public class TestService3 extends IntentService {  
    private final String TAG = "hehe";  
    //必须实现父类的构造方法  
    public TestService3()  
    {  
        super("TestService3");  
    }  
  
    //必须重写的核心方法  
    @Override  
    protected void onHandleIntent(Intent intent) {  
        //Intent是从Activity发过来的,携带识别参数,根据参数不同执行不同的任务  
        String action = intent.getExtras().getString("param");  
        if(action.equals("s1"))Log.i(TAG,"启动service1");  
        else if(action.equals("s2"))Log.i(TAG,"启动service2");  
        else if(action.equals("s3"))Log.i(TAG,"启动service3");  
          
        //让服务休眠2秒  
        try{  
            Thread.sleep(2000);  
        }catch(InterruptedException e){e.printStackTrace();}          
    }  
  
    //重写其他方法,用于查看方法的调用顺序  
    @Override  
    public IBinder onBind(Intent intent) {  
        Log.i(TAG,"onBind");  
        return super.onBind(intent);  
    }  
  
    @Override  
    public void onCreate() {  
        Log.i(TAG,"onCreate");  
        super.onCreate();  
    }  
  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
        Log.i(TAG,"onStartCommand");  
        return super.onStartCommand(intent, flags, startId);  
    }  
  
  
    @Override  
    public void setIntentRedelivery(boolean enabled) {  
        super.setIntentRedelivery(enabled);  
        Log.i(TAG,"setIntentRedelivery");  
    }  
      
    @Override  
    public void onDestroy() {  
        Log.i(TAG,"onDestroy");  
        super.onDestroy();  
    }  
      
} 

Registrar el Service en AndroidManifest.xml

<service android:name=".TestService3" android:exported="false">  
    <intent-filter >  
        <action android:name="com.test.intentservice"/>  
    </intent-filter>  
</service>  

Iniciar el servicio tres veces en MainActivity:

public class MainActivity extends Activity {  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
          
        Intent it1 = new Intent("com.test.intentservice");  
        Bundle b1 = new Bundle();  
        b1.putString("param", "s1");  
        it1.putExtras(b1);  
          
        Intent it2 = new Intent("com.test.intentservice");  
        Bundle b2 = new Bundle();  
        b2.putString("param", "s2");  
        it2.putExtras(b2);  
          
        Intent it3 = new Intent("com.test.intentservice");  
        Bundle b3 = new Bundle();  
        b3.putString("param", "s3");  
        it3.putExtras(b3);  
          
        //接着启动多次IntentService,每次启动,都会新建一个工作线程  
        //但始终只有一个IntentService实例  
        startService(it1);  
        startService(it2);  
        startService(it3);  
    }  
} 

Captura de pantalla en ejecución:

Resumen:

Cuando una tarea en segundo plano necesita dividirse en varias subtareas y ejecutarse en orden, subtareas (en pocas palabras, operaciones asíncronas). En este momento, si todavía definimos un Service normal y luego abrimos un subproceso en el método onStart, y además tenemos que controlar el subproceso, resulta muy engorroso. En ese caso, debes definir un IntentService personalizado y completar las tareas relevantes en el método onHandleIntent().


2. Comunicación entre Activity y Service

Todas nuestras operaciones anteriores inician y detienen Service a través de Activity. Supongamos que iniciamos un Service en segundo plano de descarga y queremos conocer el progreso de la tarea de descarga en Service. Entonces ciertamente se necesita comunicación entre Service y Activity, y el medio de comunicación entre ellos es el método onBind() del Service. ¡Devuelve un objeto Binder personalizado!

El flujo básico es el siguiente:

  • 1. En el Service personalizado, define una clase Binder personalizada y escribe en esa clase todos los métodos que necesitan exponerse.
  • 2. En la clase Service, instancia esta clase Binder personalizada, luego sobrescribe el método onBind() y devuelve este objeto Binder.
  • 3. En la clase Activity, instancia un objeto ServiceConnection, sobrescribe el método onServiceConnected(), luego obtén el objeto Binder y llama a los métodos relevantes.

3. Implementación de un servicio en primer plano simple

Después de aprender hasta ahora, todos sabemos que Service generalmente se ejecuta en segundo plano, pero la prioridad del sistema de Service es relativamente baja. Cuando la memoria del sistema es insuficiente, es posible que se recicle el Service que se ejecuta en segundo plano. Para esta situación, podemos usar un servicio en primer plano, para que Service no sea tan fácilmente eliminado por el sistema; aunque todavía puede ser eliminado... El llamado servicio en primer plano es la Notification que se muestra en la barra de estado.

Su implementación también es muy simple. Recientemente, el proyecto en el que trabajé justamente usó este servicio en primer plano, así que extraje el código central para compartirlo:

En la clase Service personalizada, sobrescribe onCreate() y personaliza la Notification según tus necesidades; una vez personalizada, llama a startForeground(1, objeto notification).El código central es el siguiente:

public void onCreate()
{
    super.onCreate();
    Notification.Builder localBuilder = new Notification.Builder(this);
    localBuilder.setContentIntent(PendingIntent.getActivity(this, 0, new Intent(this, MainActivity.class), 0));
    localBuilder.setAutoCancel(false);
    localBuilder.setSmallIcon(R.mipmap.ic_cow_icon);
    localBuilder.setTicker("Foreground Service Start");
    localBuilder.setContentTitle("Socket服务端");
    localBuilder.setContentText("正在运行...");
    startForeground(1, localBuilder.getNotification());
}

Captura de pantalla del resultado en ejecución:


4. Implementación de un subproceso en segundo plano con temporización simple

Además del servicio en primer plano mencionado anteriormente, en el desarrollo real Service tiene otro uso común: ejecutar tareas programadas, como el sondeo, que consiste en solicitar al servidor cada cierto intervalo de tiempo para confirmar el estado del cliente o actualizar información. Android nos proporciona dos formas de temporización: el uso de la clase Timer y el mecanismo Alarm.

El primero no es adecuado para tareas programadas que necesitan ejecutarse en segundo plano durante mucho tiempo; una vez que la CPU se suspende, las tareas programadas en Timer no pueden ejecutarse. Alarm no tiene este problema; tiene la función de despertar la CPU. Además, también hay que distinguir entre despertar la CPU y despertar la pantalla.

Flujo de uso:

  • Paso 1: Obtener el Service: AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
  • Paso 2: Configurar la tarea programada mediante el método set int anHour = 2 * 1000; long triggerAtTime = SystemClock.elapsedRealtime() + anHour; manager.set(AlarmManager.RTC_WAKEUP,triggerAtTime,pendingIntent);
  • Paso 3: Definir un ServiceEn onStartCommand, abre un subproceso de tarea para manejar algo de lógica de temporización.
  • Paso 4: Definir un Broadcast (difusión) para iniciar ServiceFinalmente, no olvides registrar este Service y el Broadcast en AndroidManifest.xml.

Explicación detallada de los parámetros: set(int type,long startTime,PendingIntent pi)

①type:Hay cinco valores opcionales:
AlarmManager.ELAPSED_REALTIME:La alarma no está disponible cuando el teléfono está en modo de suspensión. En este estado, la alarma usa tiempo relativo (relativo al inicio del sistema), y el valor de estado es 3;
AlarmManager.ELAPSED_REALTIME_WAKEUPLa alarma despierta el sistema y ejecuta la función de aviso en estado de suspensión. En este estado, la alarma también usa tiempo relativo, y el valor de estado es 2;
AlarmManager.RTCLa alarma no está disponible en estado de suspensión. En este estado, la alarma usa tiempo absoluto, es decir, el tiempo actual del sistema, con valor de estado 1;
AlarmManager.RTC_WAKEUPIndica que la alarma despierta el sistema y ejecuta la función de aviso en estado de suspensión. En este estado, la alarma usa tiempo absoluto, con valor de estado 0;
AlarmManager.POWER_OFF_WAKEUPIndica que la alarma también puede realizar la función de aviso normalmente cuando el teléfono está apagado, por lo que es uno de los estados más utilizados entre los 5 estados. En este estado, la alarma también usa tiempo absoluto, con valor de estado 4. Sin embargo, parece que este estado se ve afectado por la versión del SDK; algunas versiones no lo admiten.

PS: El primer parámetro determina el tipo del segundo parámetro. Si es REALTIME, se usa SystemClock.elapsedRealtime(); este método puede obtener los milisegundos transcurridos desde el encendido del sistema hasta ahora. Si es RTC, se usa System.currentTimeMillis(), que obtiene los milisegundos transcurridos desde el 1 de enero de 1970, 0:00 hasta ahora.

②startTime:El tiempo de primera ejecución de la alarma, en milisegundos, se puede personalizar, pero generalmente se usa el tiempo actual. Ten en cuenta que este atributo está estrechamente relacionado con el primer atributo (type). Si la alarma correspondiente al primer parámetro usa tiempo relativo (ELAPSED_REALTIMEyELAPSED_REALTIME_WAKEUPentonces este atributo debe usar tiempo relativo (relativo al tiempo de inicio del sistema), por ejemplo, el tiempo actual se expresa como: SystemClock.elapsedRealtime(); si la alarma correspondiente al primer parámetro usa tiempo absoluto (RTC, RTC_WAKEUP, POWER_OFF_WAKEUP), entonces este atributo debe usar tiempo absoluto, por ejemplo, el tiempo actual se expresa como: System.currentTimeMillis().

③PendingIntent:Está vinculado a la acción de ejecución de la alarma, como enviar una difusión, dar un aviso, etc. PendingIntent es una clase contenedora de Intent.
Ten en cuenta que, si se implementa el aviso de la alarma iniciando un servicio, la obtención del objeto PendingIntent debe usar el método Pending.getService(Context c, int i, Intent intent, int j).
Si la notificación de la alarma se implementa mediante broadcast, la obtención del objeto PendingIntent debe utilizar el método PendingIntent.getBroadcast (Context c,int i,Intent intent,int j);
Si la notificación de la alarma se implementa mediante una Activity, la obtención del objeto PendingIntent debe utilizar el método PendingIntent.getActivity(Context c,int i,Intent intent,int j).
Si estos tres métodos se usan incorrectamente, aunque no se producirá un error, no se verá el efecto de notificación de la alarma.

Además:

A partir de la versión 4.4 (API 19), el tiempo de activación de las tareas Alarm puede volverse inexacto y puede retrasarse; es una optimización del sistema para el consumo de batería. Si se necesita que sea preciso, se puede llamar al método setExtra()~

Código principal:

public class LongRunningService extends Service {
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //这里开辟一条线程,用来执行具体的逻辑操作:
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.d("BackService", new Date().toString());
            }
        }).start();
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        //这里是定时的,这里设置的是每隔两秒打印一次时间=-=,自己改
        int anHour = 2 * 1000;
        long triggerAtTime = SystemClock.elapsedRealtime() + anHour;
        Intent i = new Intent(this,AlarmReceiver.class);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
        return super.onStartCommand(intent, flags, startId);
    }
}

AlarmReceiver.java

public class AlarmReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context,LongRunningService.class);
        context.startService(i);
    }
}

Resumen de esta sección:

En esta sección continuamos con un estudio más profundo de Service, IntentService y Service, así como dos casos comunes de Service en el desarrollo real: la implementación de Service en primer plano y la implementación de Service en segundo plano. En la siguiente sección seguiremos estudiando el AIDL de Service y la comunicación entre procesos. Esperen con interés~


Referencias:«Primera línea de código Android» — Guo Lin: ¡un muy buen libro de introducción a Android!