Introduction de la section

Dans la section précédente, nous avons découvert le cycle de vie de Service et les deux méthodes de démarrage d'un Service. Dans cette section, nous continuons à approfondir notre compréhension d'IntentService dans Service, ainsi que des exemples d'utilisation de Service : implémentation de services de premier plan et d'interrogation !


1. Utilisation d'IntentService

Après la section précédente, nous savons déjà comment définir et démarrer un Service. Mais si nous plaçons directement un thread chronophage dans la méthode onStart() d'un Service, bien que cela soit possible, cela peut facilement provoquer une exception ANR (Application Not Responding). Dans l'introduction officielle d'Android à Service, il y a le passage suivant :

Traduction directe :

1. Un Service n'est pas un processus séparé ; il s'exécute dans le même processus que son application.
2. Un Service n'est pas un thread, ce qui signifie que nous devons éviter les opérations chronophages dans un Service.

Par conséquent, Android nous fournit une alternative pour résoudre le problème ci-dessus, qui est ce dont nous allons parler ensuiteIntentService; IntentService est une classe qui hérite de Service et gère les requêtes asynchrones. Dans IntentService, il y a un thread de travail pour gérer les opérations chronophages, et les enregistrements d'Intent demandés sont ajoutés à une file d'attente.

Flux de travail :

Le client démarre IntentService via startService(Intent) ; nous n'avons pas besoin de contrôler manuellement IntentService. Lorsque la tâche est terminée, IntentService s'arrête automatiquement. IntentService peut être démarré plusieurs fois, et chaque opération chronophage sera exécutée dans la méthode de rappel onHandleIntent d'IntentService de manière à former une file d'attente de travail, et un seul thread de travail sera exécuté à la fois. Après avoir terminé le premier, il passe au deuxième, et ainsi de suite !

Vient ensuite la démonstration du code. La plupart du code en ligne compare Service et IntentService, en définissant un temps de sommeil suffisamment long pour démontrer l'exception ANR de Service, puis en montrant à quel point IntentService est bon. Nous ne démontrerons pas Service ici. Les exemples en ligne définissent un Service personnalisé puis utilisent Thread.sleep(20000) dans la méthode onStart() pour provoquer une exception ANR. Si vous êtes intéressé, vous pouvez essayer d'écrire le code vous-même. Ici, nous démontrons uniquement l'utilisation d'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();  
    }  
      
} 

Enregistrer le Service dans AndroidManifest.xml

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

Démarrer le service trois fois dans 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);  
    }  
} 

Capture d'écran de l'exécution :

Résumé :

Lorsqu'une tâche d'arrière-plan doit être divisée en plusieurs sous-tâches et exécutée en séquence, les sous-tâches (autrement dit, des opérations asynchrones) - si nous définissons encore un Service normal puis créons des threads dans la méthode onStart, et devons ensuite contrôler les threads, cela devient très fastidieux. À ce stade, nous devrions définir un IntentService personnalisé puis accomplir les tâches pertinentes dans la méthode onHandleIntent() !


2. Communication entre Activity et Service

Nos opérations précédentes démarraient et arrêtaient le Service via l'Activity. Supposons que nous démarrions un Service en arrière-plan pour télécharger, et que nous voulions connaître la progression de la tâche de téléchargement dans le Service ! Cela nécessite alors certainement une communication entre le Service et l'Activity, et le médium de leur communication est la méthode onBind() du Service ! Elle renvoie un objet Binder personnalisé que nous définissons !

Le processus de base est le suivant :

  • 1. Dans un Service personnalisé, définissez une classe Binder personnalisée, et écrivez toutes les méthodes qui doivent être exposées dans cette classe !
  • 2. Dans la classe Service, instanciez cette classe Binder personnalisée, puis redéfinissez la méthode onBind() et renvoyez cet objet Binder !
  • 3. Dans la classe Activity, instanciez un objet ServiceConnection, redéfinissez la méthode onServiceConnected(), puis obtenez l'objet Binder et appelez les méthodes pertinentes !

3. Implémentation d'un Service de premier plan simple

Jusqu'à présent, nous savons tous que Service s'exécute généralement en arrière-plan, mais la priorité système de Service est relativement faible. Lorsque la mémoire système est insuffisante, le Service exécuté en arrière-plan peut être recyclé. Pour cette situation, nous pouvons utiliser un service de premier plan pour rendre le Service légèrement moins susceptible d'être tué par le système. Bien sûr, il est toujours possible d'être tué... Le soi-disant service de premier plan est la Notification affichée dans la barre d'état !

C'est également très simple à implémenter. Le projet sur lequel j'ai récemment travaillé utilisait justement ce service de premier plan, j'en ai donc extrait le code principal et je le partage :

Dans la classe Service personnalisée, redéfinissez onCreate(), puis personnalisez la Notification selon vos besoins. Après personnalisation, appelez startForeground(1, notification object) et c'est tout !Le code principal est le suivant :

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

Capture d'écran de l'effet d'exécution :


4. Implémentation d'un simple thread d'arrière-plan planifié

En plus du service de premier plan ci-dessus, Service a un autre usage courant dans le développement réel : exécuter des tâches planifiées, comme l'interrogation périodique, qui demande au serveur à intervalles réguliers pour confirmer l'état du client ou mettre à jour des informations, etc. ! Android nous fournit deux méthodes de temporisation : utiliser la classe Timer et le mécanisme Alarm !

Le premier ne convient pas aux tâches planifiées qui doivent s'exécuter en arrière-plan pendant une longue période. Une fois que le CPU dort, les tâches planifiées dans Timer ne peuvent pas s'exécuter ; Alarm n'a pas ce problème. Il a la fonction de réveiller le CPU. De plus, nous devons également distinguer le réveil du CPU du réveil de l'écran !

Processus d'utilisation :

  • Étape 1 : Obtenir le Service : AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
  • Étape 2 : Définir la tâche planifiée via la méthode set int anHour = 2 * 1000; long triggerAtTime = SystemClock.elapsedRealtime() + anHour; manager.set(AlarmManager.RTC_WAKEUP,triggerAtTime,pendingIntent);
  • Étape 3 : Définir un ServiceDans onStartCommand, démarrez un thread de travail pour gérer une certaine logique de temporisation.
  • Étape 4 : Définir un Broadcast pour démarrer le Service.Enfin, n'oubliez pas d'enregistrer le Service et le Broadcast dans AndroidManifest.xml !

Explication des paramètres : set(int type,long startTime,PendingIntent pi)

①type :Il y a cinq valeurs optionnelles :
AlarmManager.ELAPSED_REALTIME :L'alarme n'est pas disponible lorsque le téléphone est en mode veille. Dans cet état, l'alarme utilise un temps relatif (relatif au démarrage du système), avec la valeur d'état 3 ;
AlarmManager.ELAPSED_REALTIME_WAKEUPL'alarme réveillera le système et exécutera la fonction de notification lorsque le système est en veille. Dans cet état, l'alarme utilise également un temps relatif, avec la valeur d'état 2 ;
AlarmManager.RTCL'alarme n'est pas disponible lorsque le système est en veille. Dans cet état, l'alarme utilise un temps absolu, c'est-à-dire l'heure actuelle du système, avec la valeur d'état 1 ;
AlarmManager.RTC_WAKEUPIndique que l'alarme réveillera le système et exécutera la fonction de notification lorsque le système est en veille. Dans cet état, l'alarme utilise un temps absolu, avec la valeur d'état 0 ;
AlarmManager.POWER_OFF_WAKEUPIndique que l'alarme peut également exécuter normalement la fonction de notification lorsque le téléphone est éteint, c'est donc l'un des états les plus utilisés parmi les cinq états. Dans cet état, l'alarme utilise également un temps absolu, avec la valeur d'état 4. Cependant, cet état semble être affecté par la version du SDK, et certaines versions ne le prennent pas en charge ;

PS : Le premier paramètre détermine le type du deuxième paramètre. S'il s'agit de REALTIME, utilisez : la méthode SystemClock.elapsedRealtime() pour obtenir le nombre de millisecondes écoulées depuis le démarrage du système jusqu'à présent. S'il s'agit de RTC, utilisez : System.currentTimeMillis() pour obtenir le nombre de millisecondes écoulées depuis le 1970.1.1 0:00 jusqu'à présent.

②startTime :L'heure de première exécution de l'alarme, en millisecondes. Vous pouvez personnaliser l'heure, mais généralement l'heure actuelle est utilisée. Il convient de noter que cette propriété est étroitement liée à la première propriété (type). Si l'alarme correspondant au premier paramètre utilise un temps relatif (ELAPSED_REALTIMEetELAPSED_REALTIME_WAKEUP), alors cette propriété doit utiliser un temps relatif (relatif au temps de démarrage du système). Par exemple, l'heure actuelle est exprimée par : SystemClock.elapsedRealtime(); si l'alarme correspondant au premier paramètre utilise un temps absolu (RTC, RTC_WAKEUP, POWER_OFF_WAKEUP), alors cette propriété doit utiliser un temps absolu. Par exemple, l'heure actuelle est exprimée par : System.currentTimeMillis().

③PendingIntent :Il lie l'action d'exécution de l'alarme, comme envoyer une diffusion, émettre une notification, etc. PendingIntent est une classe d'encapsulation pour Intent.
Il convient de noter que si la notification d'alarme est implémentée en démarrant un service, l'objet PendingIntent doit être obtenu à l'aide de la méthode Pending.getService(Context c, int i, Intent intent, int j) ;
Si la notification d'alarme est implémentée via une diffusion, l'objet PendingIntent doit être obtenu à l'aide de la méthode PendingIntent.getBroadcast (Context c,int i,Intent intent,int j) ;
Si la notification d'alarme est implémentée à l'aide d'une Activity, l'objet PendingIntent doit être obtenu à l'aide de la méthode PendingIntent.getActivity(Context c,int i,Intent intent,int j).
Si ces trois méthodes sont utilisées de manière incorrecte, bien qu'aucune erreur ne soit signalée, l'effet de notification de l'alarme ne sera pas visible.

De plus :

À partir de la version 4.4 (API 19), l'heure de déclenchement des tâches d'alarme peut devenir imprécise et peut être retardée. Il s'agit de l'optimisation du système pour la consommation d'énergie. Si la précision est requise, vous pouvez appeler la méthode setExtra()~

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

Résumé de la section :

Dans cette section, nous continuons d'étudier Service plus en profondeur, IntentService, ainsi que deux cas courants d'utilisation de Service en développement réel : l'implémentation d'un Service de premier plan et l'implémentation d'un Service d'arrière-plan ! Dans la section suivante, nous continuerons d'étudier AIDL de Service et la communication inter-processus. Restez à l'écoute~


Références :"Première ligne de code Android" — Guo Lin : un très bon livre d'introduction à Android !