Quel est le cycle de vie des services dans Android?

Le service n'a pas d'interface utilisateur et fonctionne en arrière-plan. Son cycle de vie est géré par trois méthodes principales:

• onCreate(): Appelé une première fois lors de la création du service. L'initialisation y est effectuée.
• onStartCommand() / méthode appelée lors de la liaison (par exemple, onBind()): onStartCommand() est appelé lors du démarrage du service via startService(). Il retourne un drapeau indiquant comment le système doit restaurer le service s'il est tué. onBind() est appelé lors de la liaison d'un client au service via bindService().
• onDestroy(): Appelé lorsque le service est détruit. Toutes les ressources y sont libérées.

Il existe deux types de services influençant le cycle de vie:

• Service démarré (Started Service): Démarré par startService(). Fonctionne jusqu'à ce qu'il soit explicitement arrêté par stopSelf() ou stopService(). Le système tentera de le redémarrer après sa destruction si onStartCommand() a retourné le drapeau approprié.
• Service lié (Bound Service): Démarré par bindService(). Existe tant qu'au moins un client actif y est lié. Lorsqu'ils se déconnectent tous, le service est détruit. onBind() retourne une implémentation de IBinder, utilisée pour interagir avec le service.

Diagramme du cycle de vie:

        Start Service --+--> onStartCommand() --+--> En cours d'exécution
                        |                         |
        Bind Service ---+--> onBind() -----------+--> Lié
                        |
        onCreate() -----+
                        |
                        +--> onRebind()
                        |
        onDestroy() <---+-------------------------+---- Délié <--- unbindService()
                                                 |
                                                 +---- Arrêté <--- stopSelf() / stopService()

Points clés:

• onCreate() est appelé une seule fois.
• onStartCommand() peut être appelé plusieurs fois si startService() est appelé de manière répétée.
• Le service fonctionne dans le fil principal de l'interface utilisateur par défaut. Les opérations longues doivent être effectuées dans un thread séparé ou avec IntentService.
• Les services liés ont un cycle de vie plus complexe, dépendant de l'état des clients.

Exemple de onStartCommand():

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    // Effectuer une action
    // Par exemple, commencer un travail en arrière-plan
    
    // Retourner le drapeau déterminant le comportement du système lors de la destruction du service
    return START_STICKY; // Le service sera restauré s'il est tué
}

Exemple de onBind():

private final IBinder binder = new LocalBinder();

public class LocalBinder extends Binder {
    MyService getService() {
        // Retourner l'instance du service pour les clients
        return MyService.this;
    }
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
    return binder;
}

@Override
public boolean onUnbind(Intent intent) {
    // Appelé lorsque tous les clients se déconnectent
    return super.onUnbind(intent);
}