Un Service est un composant d'application qui peut exécuter des opérations de longue durée en arrière-plan. Il ne fournit pas d'interface utilisateur. Une fois démarré, un service peut continuer à s'exécuter pendant un certain temps, même après que l'utilisateur est passé à une autre application. De plus, un composant peut se lier à un service pour interagir avec lui et même effectuer une communication inter-processus (IPC). Par exemple, un service peut gérer des transactions réseau, lire de la musique, effectuer des E/S de fichiers ou interagir avec un fournisseur de contenu, le tout en arrière-plan.
Attention : Un service s'exécute dans le thread principal de son processus d'hébergement. Il ne crée pas son propre thread et ne s'exécute pas dans un processus distinct, sauf indication contraire de votre part. Vous devez exécuter toutes les opérations de blocage sur un thread distinct au sein du service pour éviter les erreurs "L'application ne répond pas" (ANR).
Types de services
Voici les trois types de services :
- Premier plan
-
Un service de premier plan effectue une opération visible par l'utilisateur. Par exemple, une application audio utilise un service de premier plan pour lire une piste audio. Les services de premier plan doivent afficher une notification. Les services de premier plan continuent de s'exécuter même lorsque l'utilisateur n'interagit pas avec l'application.
Lorsque vous utilisez un service de premier plan, vous devez afficher une notification pour que les utilisateurs sachent que le service est en cours d'exécution. Cette notification ne peut pas être ignorée, sauf si le service est arrêté ou supprimé du premier plan.
Découvrez comment configurer des services de premier plan dans votre application.
Remarque : L'API WorkManager offre un moyen flexible de planifier des tâches et peut exécuter ces tâches en tant que services de premier plan si nécessaire. Dans de nombreux cas, il est préférable d'utiliser WorkManager plutôt que d'utiliser directement des services de premier plan.
- Arrière-plan
- Un service d'arrière-plan effectue une opération qui n'est pas directement remarquée par l'utilisateur. Par exemple, si une application utilise un service pour compacter son espace de stockage, il s'agit généralement d'un service d'arrière-plan.
Remarque : Si votre application cible le niveau d'API 26 ou supérieur, le système impose des restrictions sur l'exécution des services d'arrière-plan lorsque l'application elle-même n'est pas au premier plan. Dans la plupart des cas, par exemple, vous ne devez pas accéder aux informations de localisation en arrière-plan. À la place, planifiez des tâches à l'aide de WorkManager.
- Lié
- Un service est lié lorsqu'un composant d'application s'y lie en appelant
bindService(). Un service lié offre une interface client-serveur qui permet aux composants d'interagir avec le service, d'envoyer des requêtes, de recevoir des résultats et même de le faire entre les processus avec la communication inter-processus (IPC). Un service lié ne s'exécute que tant qu'un autre composant d'application lui est lié. Plusieurs composants peuvent être liés au service en même temps, mais lorsqu'ils sont tous dissociés, le service est détruit.
Bien que cette documentation traite généralement des services démarrés et des services liés séparément, votre service peut fonctionner des deux manières : il peut être démarré (pour s'exécuter indéfiniment) et autoriser la liaison. Il vous suffit d'implémenter quelques méthodes de rappel : onStartCommand() pour permettre aux composants de le démarrer et onBind() pour autoriser la liaison.
Que votre service soit démarré, lié ou les deux, n'importe quel composant d'application peut l'utiliser (même à partir d'une application distincte), de la même manière que n'importe quel composant peut utiliser une activité, en le démarrant avec un Intent. Toutefois, vous pouvez déclarer le service comme privé dans le fichier manifeste et bloquer l'accès à partir d'autres applications.
Pour en savoir plus, consultez la section Déclarer le service dans le fichier manifeste.
Choisir entre un service et un thread
Un service est simplement un composant qui peut s'exécuter en arrière-plan, même lorsque l'utilisateur n'interagit pas avec votre application. Vous ne devez donc créer un service que si vous en avez besoin.
Si vous devez effectuer des tâches en dehors de votre thread principal, mais uniquement lorsque l'utilisateur interagit avec votre application, vous devez créer un thread dans le contexte d'un autre composant d'application. Par exemple, si vous souhaitez écouter de la musique, mais uniquement pendant l'exécution de votre activité, vous pouvez créer un thread dans onCreate(), commencer à l'exécuter dans onStart() et l'arrêter dans onStop().
Envisagez également d'utiliser des pools de threads et des exécuteurs du package java.util.concurrent ou des coroutines Kotlin au lieu de la classe Thread traditionnelle. Pour en savoir plus sur le déplacement de l'exécution vers des threads d'arrière-plan, consultez le document Exécution de threads sur Android.
N'oubliez pas que si vous utilisez un service, il s'exécute toujours par défaut dans le thread principal de votre application. Vous devez donc toujours créer un thread dans le service s'il effectue des opérations intensives ou bloquantes.
Principes de base
Pour créer un service, vous devez créer une sous-classe de Service ou utiliser l'une de ses sous-classes existantes. Dans votre implémentation, vous devez remplacer certaines méthodes de rappel qui gèrent les aspects clés du cycle de vie du service et fournir un mécanisme permettant aux composants de se lier au service, le cas échéant. Voici les méthodes de rappel les plus importantes que vous devez remplacer :
onStartCommand()- Le système appelle cette méthode en appelant
startService()lorsqu'un autre composant (comme une activité) demande le démarrage du service. Lorsque cette méthode s'exécute, le service est démarré et peut s'exécuter en arrière-plan indéfiniment. Si vous implémentez cette méthode, vous devez arrêter le service une fois sa tâche terminée en appelantstopSelf()oustopService(). Si vous souhaitez uniquement fournir une liaison, vous n'avez pas besoin d'implémenter cette méthode. onBind()- Le système appelle cette méthode en appelant
bindService()lorsqu'un autre composant souhaite se lier au service (par exemple, pour effectuer un RPC). Dans votre implémentation de cette méthode, vous devez fournir une interface que les clients utilisent pour communiquer avec le service en renvoyant unIBinder. Vous devez toujours implémenter cette méthode. Toutefois, si vous ne souhaitez pas autoriser la liaison, vous devez renvoyer la valeur "null". onCreate()- Le système appelle cette méthode pour effectuer des procédures de configuration ponctuelles lors de la création initiale du service (avant d'appeler
onStartCommand()ouonBind()). Si le service est déjà en cours d'exécution, cette méthode n'est pas appelée. onDestroy()- Le système appelle cette méthode lorsque le service n'est plus utilisé et qu'il est détruit. Votre service doit implémenter cette méthode pour nettoyer toutes les ressources telles que les threads, les écouteurs enregistrés ou les récepteurs. Il s'agit du dernier appel reçu par le service.
Si un composant démarre le service en appelant startService() (ce qui entraîne un appel à onStartCommand()), le service continue de s'exécuter jusqu'à ce qu'il s'arrête lui-même avec stopSelf() ou qu'un autre composant l'arrête en appelant stopService().
Si un composant appelle bindService() pour créer le service et que onStartCommand() n'est pas appelé, le service ne s'exécute que tant que le composant lui est lié. Une fois que le service est dissocié de tous ses clients, le système le détruit.
Le système Android n'arrête un service que lorsque la mémoire est faible et qu'il doit récupérer des ressources système pour l'activité qui est au premier plan. Si le service est lié à une activité qui est sélectionnée par l'utilisateur, il est moins susceptible d'être arrêté. Si le service est déclaré comme s'exécutant au premier plan, il est rarement arrêté.
Si le service est démarré et s'exécute sur une longue période, le système abaisse sa position dans la liste des tâches en arrière-plan au fil du temps, et le service devient très susceptible d'être arrêté. Si votre service est démarré, vous devez le concevoir de manière à gérer correctement les redémarrages par le système. Si le système arrête votre service, il le redémarre dès que des ressources sont disponibles, mais cela dépend également de la valeur que vous renvoyez depuis onStartCommand(). Pour en savoir plus sur les cas où le système peut détruire un service, consultez le document Processus et threads.
Dans les sections suivantes, vous verrez comment créer les méthodes de service startService() et bindService(), et comment les utiliser à partir d'autres composants d'application.
Déclarer un service dans le fichier manifeste
Vous devez déclarer tous les services dans le fichier manifeste de votre application, comme vous le faites pour les activités et les autres composants.
Pour déclarer votre service, ajoutez un élément <service> en tant qu'enfant de l'élément <application>. Voici un exemple :
<manifest ... > ... <application ... > <service android:name=".ExampleService" /> ... </application> </manifest>
Pour en savoir plus sur la déclaration de votre service dans le fichier manifeste, consultez la documentation de référence sur l'élément <service>.
Vous pouvez inclure d'autres attributs dans l'élément <service> pour définir des propriétés telles que les autorisations requises pour démarrer le service et le processus dans lequel le service doit s'exécuter. L'attribut android:name est le seul attribut obligatoire. Il spécifie le nom de classe du service. Une fois votre application publiée, ne modifiez pas ce nom pour éviter de casser le code en raison de la dépendance à des intents explicites pour démarrer ou lier le service (consultez l'article de blog Things That Cannot Change).
Attention : Pour garantir la sécurité de votre application, utilisez toujours un intent explicite lorsque vous démarrez un Service et ne déclarez pas de filtres d'intent pour vos services. L'utilisation d'un intent implicite pour démarrer un service représente un risque de sécurité, car vous ne pouvez pas savoir avec certitude quel service répondra à l'intent et l'utilisateur ne peut pas voir quel service démarre. À partir d'Android 5.0 (niveau d'API 21), le système génère une exception si vous appelez bindService() avec un intent implicite.
Vous pouvez vous assurer que votre service n'est disponible que pour votre application en incluant l'attribut android:exported et en le définissant sur false. Cela empêche les autres applications de démarrer votre service, même lorsqu'elles utilisent un intent explicite.
Remarque : Les utilisateurs peuvent voir les services qui s'exécutent sur leur appareil. S'ils voient un service qu'ils ne reconnaissent pas ou auquel ils ne font pas confiance, ils peuvent l'arrêter. Pour éviter que votre service ne soit arrêté accidentellement par les utilisateurs, vous devez ajouter l'attribut android:description à l'élément <service> dans le fichier manifeste de votre application. Dans la description, fournissez une courte phrase expliquant ce que fait le service et les avantages qu'il offre.
Créer un service démarré
Un service démarré est un service qu'un autre composant démarre en appelant startService(), ce qui entraîne un appel à la méthode onStartCommand() du service.
Lorsqu'un service est démarré, son cycle de vie est indépendant du composant qui l'a démarré. Le service peut s'exécuter en arrière-plan indéfiniment, même si le composant qui l'a démarré est détruit. Par conséquent, le service doit s'arrêter lui-même lorsque sa tâche est terminée en appelant stopSelf(), ou un autre composant peut l'arrêter en appelant stopService().
Un composant d'application tel qu'une activité peut démarrer le service en appelant startService() et en transmettant un Intent qui spécifie le service et inclut toutes les données que le service doit utiliser. Le service reçoit ce Intent dans la méthode onStartCommand().
Par exemple, supposons qu'une activité doive enregistrer des données dans une base de données en ligne. L'activité peut démarrer un service associé et lui transmettre les données à enregistrer en transmettant un intent à startService(). Le service reçoit l'intent dans onStartCommand(), se connecte à Internet et effectue la transaction de base de données. Une fois la transaction terminée, le service s'arrête et est détruit.
Attention : Un service s'exécute dans le même processus que l'application dans laquelle il est déclaré et, par défaut, dans le thread principal de cette application. Si votre service effectue des opérations intensives ou bloquantes pendant que l'utilisateur interagit avec une activité de la même application, le service ralentit les performances de l'activité. Pour éviter d'affecter les performances de l'application, démarrez un nouveau thread dans le service.
La classe Service est la classe de base de tous les services. Lorsque vous étendez cette classe, il est important de créer un thread dans lequel le service peut effectuer l'ensemble de son travail. Par défaut, le service utilise le thread principal de votre application, ce qui peut ralentir les performances de toute activité exécutée par votre application.
Le framework Android fournit également la sous-classe IntentService de Service, qui utilise un thread de travail pour gérer toutes les requêtes de démarrage, une par une. L'utilisation de cette classe n'est pas recommandée pour les nouvelles applications, car elle ne fonctionnera pas correctement à partir d'Android 8 Oreo en raison de l'introduction des limites d'exécution en arrière-plan.
De plus, elle est obsolète à partir d'Android 11.
Vous pouvez utiliser JobIntentService en remplacement de IntentService, qui est compatible avec les versions plus récentes d'Android.
Les sections suivantes décrivent comment implémenter votre propre service personnalisé. Toutefois, nous vous recommandons vivement d'utiliser WorkManager pour la plupart des cas d'utilisation. Consultez le guide de traitement en arrière-plan sur Android pour déterminer s'il existe une solution qui répond à vos besoins.
Étendre la classe Service
Vous pouvez étendre la classe Service pour gérer chaque intent entrant. Voici à quoi peut ressembler une implémentation de base :
class HelloService : Service() { private var serviceLooper: Looper? = null private var serviceHandler: ServiceHandler? = null // Handler that receives messages from the thread. private inner class ServiceHandler(looper: Looper) : Handler(looper) { override fun handleMessage(msg: Message) { // Normally we would do some work here, like download a file. // For our sample, we just sleep for 5 seconds. try { Thread.sleep(5000) } catch (e: InterruptedException) { // Restore interrupt status. Thread.currentThread().interrupt() } // Stop the service using the startId, so that we don't stop // the service in the middle of handling another job. stopSelf(msg.arg1) } } override fun onCreate() { // Start up the thread running the service. Note that we create a // separate thread because the service normally runs in the process's // main thread, which we don't want to block. We also make it // background priority so CPU-intensive work will not disrupt our UI. HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply { start() // Get the HandlerThread's Looper and use it for our Handler. serviceLooper = looper serviceHandler = ServiceHandler(looper) } } override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int { Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show() // For each start request, send a message to start a job and deliver the // start ID so we know which request we're stopping when we finish the job. serviceHandler?.obtainMessage()?.also { msg -> msg.arg1 = startId serviceHandler?.sendMessage(msg) } // If we get killed, after returning from here, restart. return START_STICKY } override fun onBind(intent: Intent): IBinder? { // We don't provide binding, so return null. return null } override fun onDestroy() { Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show() } }
L'exemple de code gère tous les appels entrants dans onStartCommand() et publie le travail sur un Handler s'exécutant sur un thread d'arrière-plan. Il fonctionne comme un IntentService et traite toutes les requêtes de manière séquentielle, l'une après l'autre.
Vous pouvez modifier le code pour exécuter le travail sur un pool de threads, par exemple si vous souhaitez exécuter plusieurs requêtes simultanément.
Notez que la méthode onStartCommand() doit renvoyer un entier. L'entier est une valeur qui décrit comment le système doit poursuivre le service s'il l'arrête. La valeur renvoyée par onStartCommand() doit être l'une des constantes suivantes :
START_NOT_STICKY- Si le système arrête le service après le renvoi de
onStartCommand(), ne recréez pas le service, sauf s'il existe des intents en attente à diffuser. Il s'agit de l'option la plus sûre pour éviter d'exécuter votre service lorsqu'il n'est pas nécessaire et lorsque votre application peut simplement redémarrer les tâches non terminées. START_STICKY- Si le système arrête le service après le renvoi de
onStartCommand(), recréez le service et appelezonStartCommand(), mais ne renvoyez pas le dernier intent. À la place, le système appelleonStartCommand()avec un intent nul, sauf s'il existe des intents en attente pour démarrer le service. Dans ce cas, ces intents sont diffusés. Cette option convient aux lecteurs multimédias (ou services similaires) qui n'exécutent pas de commandes, mais qui s'exécutent indéfiniment et attendent une tâche. START_REDELIVER_INTENT- Si le système arrête le service après le renvoi de
onStartCommand(), recréez le service et appelezonStartCommand()avec le dernier intent envoyé au service. Tous les intents en attente sont diffusés à tour de rôle. Cette option est adaptée aux services qui effectuent activement une tâche qui doit être immédiatement reprise, comme le téléchargement d'un fichier.
Pour en savoir plus sur ces valeurs de retour, consultez la documentation de référence associée à chaque constante.
Démarrer un service
Vous pouvez démarrer un service à partir d'une activité ou d'un autre composant d'application en transmettant un Intent à startService() ou startForegroundService(). Le système Android appelle la méthode onStartCommand() du service et lui transmet l'Intent, qui spécifie le service à démarrer.
Remarque : Si votre application cible le niveau d'API 26 ou supérieur, le système impose des restrictions sur l'utilisation ou la création de services d'arrière-plan, sauf si l'application elle-même est au premier plan. Si une application doit créer un service de premier plan, elle doit appeler startForegroundService(). Cette méthode crée un service d'arrière-plan, mais elle signale au système que le service va passer au premier plan. Une fois le service créé, il doit appeler sa méthode startForeground() dans un délai de cinq secondes.
Par exemple, une activité peut démarrer l'exemple de service de la section précédente (HelloService) à l'aide d'un intent explicite avec startService(), comme illustré ici :
startService(Intent(this, HelloService::class.java))
La méthode startService() est renvoyée immédiatement, et le système Android appelle la méthode onStartCommand() du service. Si le service n'est pas déjà en cours d'exécution, le système appelle d'abord onCreate(), puis onStartCommand().
Si le service ne fournit pas non plus de liaison, l'intent fourni avec startService() est le seul mode de communication entre le composant d'application et le service. Toutefois, si vous souhaitez que le service renvoie un résultat, le client qui démarre le service peut créer un PendingIntent pour une diffusion (avec getBroadcast()) et le transmettre au service dans l'Intent qui démarre le service. Le service peut ensuite utiliser la diffusion pour fournir un résultat.
Plusieurs requêtes de démarrage du service entraînent plusieurs appels correspondants à la méthode onStartCommand() du service. Toutefois, une seule requête d'arrêt du service (avec stopSelf() ou stopService()) est requise pour l'arrêter.
Arrêter un service
Un service démarré doit gérer son propre cycle de vie. En d'autres termes, le système n'arrête pas ni ne détruit le service, sauf s'il doit récupérer de la mémoire système, et le service continue de s'exécuter après le renvoi de onStartCommand(). Le service doit s'arrêter lui-même en appelant stopSelf(), ou un autre composant peut l'arrêter en appelant stopService().
Une fois que l'arrêt est demandé avec stopSelf() ou stopService(), le système détruit le service dès que possible.
Si votre service gère plusieurs requêtes vers onStartCommand() simultanément, vous ne devez pas l'arrêter lorsque vous avez terminé de traiter une requête de démarrage, car vous avez peut-être reçu une nouvelle requête de démarrage (l'arrêt à la fin de la première requête mettrait fin à la seconde). Pour éviter ce problème, vous pouvez utiliser stopSelf(int) pour vous assurer que votre requête d'arrêt du service est toujours basée sur la requête de démarrage la plus récente. Autrement dit, lorsque vous appelez stopSelf(int), vous transmettez l'ID de la requête de démarrage (le startId envoyé à onStartCommand()) auquel correspond votre requête d'arrêt. Ensuite, si le service reçoit une nouvelle requête de démarrage avant que vous ne puissiez appeler stopSelf(int), l'ID ne correspond pas et le service ne s'arrête pas.
Attention : Pour éviter de gaspiller les ressources système et de consommer la batterie, assurez-vous que votre application arrête ses services lorsqu'elle a terminé son travail.
Si nécessaire, d'autres composants peuvent arrêter le service en appelant stopService(). Même si vous activez la liaison pour le service, vous devez toujours l'arrêter vous-même s'il reçoit un appel à onStartCommand().
Pour en savoir plus sur le cycle de vie d'un service, consultez la section Gérer le cycle de vie d'un service ci-dessous.
Créer un service lié
Un service lié permet aux composants d'application de s'y lier en appelant bindService() pour créer une connexion de longue durée.
En général, il n'autorise pas les composants à le démarrer en appelant startService().
Créez un service lié lorsque vous souhaitez interagir avec le service à partir d'activités et d'autres composants de votre application, ou pour exposer certaines fonctionnalités de votre application à d'autres applications via la communication inter-processus (IPC).
Pour créer un service lié, implémentez la méthode de rappel onBind() afin de renvoyer un IBinder qui définit l'interface de communication avec le service. D'autres composants d'application peuvent ensuite appeler bindService() pour récupérer l'interface et commencer à appeler des méthodes sur le service. Le service n'existe que pour diffuser le composant d'application qui lui est lié. Par conséquent, lorsqu'aucun composant n'est lié au service, le système le détruit.
Vous n'avez pas besoin d'arrêter un service lié de la même manière que lorsque le service est démarré via onStartCommand().
Pour créer un service lié, vous devez définir l'interface qui spécifie comment un client peut communiquer avec le service. Cette interface entre le service et un client doit être une implémentation de IBinder et correspond à ce que votre service doit renvoyer à partir de la méthode de rappel onBind(). Une fois que le client a reçu le IBinder, il peut commencer à interagir avec le service via cette interface.
Plusieurs clients peuvent se lier au service simultanément. Lorsqu'un client a fini d'interagir avec le service, il appelle unbindService() pour annuler l'association.
Lorsqu'aucun client n'est lié au service, le système détruit le service.
Il existe plusieurs façons d'implémenter un service lié, et l'implémentation est plus complexe que celle d'un service démarré. C'est pourquoi la discussion sur les services liés apparaît dans un document distinct sur les services liés.
Envoi de notifications à l'utilisateur
Lorsqu'un service est en cours d'exécution, il peut avertir l'utilisateur des événements à l'aide de notifications de snackbar ou de notifications de la barre d'état.
Une notification snackbar est un message qui s'affiche sur la surface de la fenêtre actuelle pendant un court instant avant de disparaître. Une notification de la barre d'état fournit une icône dans la barre d'état avec un message que l'utilisateur peut sélectionner pour effectuer une action (par exemple, démarrer une activité).
En règle générale, une notification de la barre d'état est la meilleure technique à utiliser lorsqu'une tâche en arrière-plan, telle que le téléchargement d'un fichier, est terminée et que l'utilisateur peut désormais agir dessus. Lorsque l'utilisateur sélectionne la notification dans la vue développée, la notification peut lancer une activité (par exemple, pour afficher le fichier téléchargé).
Gérer le cycle de vie d'un service
Le cycle de vie d'un service est beaucoup plus simple que celui d'une activité. Toutefois, il est encore plus important de prêter une attention particulière à la façon dont votre service est créé et détruit, car un service peut s'exécuter en arrière-plan sans que l'utilisateur en soit conscient.
Le cycle de vie du service, de sa création à sa destruction, peut suivre l'un de ces deux chemins :
- Un service démarré
Le service est créé lorsqu'un autre composant appelle
startService(). Le service s'exécute ensuite indéfiniment et doit s'arrêter lui-même en appelantstopSelf(). Un autre composant peut également arrêter le service en appelantstopService(). Lorsque le service est arrêté, le système le détruit. - Un service lié
Le service est créé lorsqu'un autre composant (un client) appelle
bindService(). Le client communique ensuite avec le service via une interfaceIBinder. Le client peut fermer la connexion en appelantunbindService(). Plusieurs clients peuvent se lier au même service. Lorsque tous se dissocient, le système détruit le service. Le service n'a pas besoin de s'arrêter lui-même.
Ces deux parcours ne sont pas entièrement distincts. Vous pouvez lier un service déjà démarré avec startService(). Par exemple, vous pouvez démarrer un service de musique de fond en appelant startService() avec un Intent qui identifie la musique à lire. Plus tard, par exemple lorsque l'utilisateur souhaite contrôler le lecteur ou obtenir des informations sur le titre en cours de lecture, une activité peut se lier au service en appelant bindService(). Dans ce cas, stopService() ou stopSelf() n'arrête pas réellement le service tant que tous les clients ne sont pas dissociés.
Implémenter les rappels de cycle de vie
Comme une activité, un service dispose de méthodes de rappel de cycle de vie que vous pouvez implémenter pour surveiller les changements d'état du service et effectuer des tâches aux moments appropriés. Le squelette de service suivant illustre chacune des méthodes de cycle de vie :
class ExampleService : Service() { private var startMode: Int = 0 // indicates how to behave if the service is killed private var binder: IBinder? = null // interface for clients that bind private var allowRebind: Boolean = false // indicates whether onRebind should be used override funonCreate() { // The service is being created } override funonStartCommand(intent: Intent?, flags: Int, startId: Int): Int { // The service is starting, due to a call to startService() return startMode } override funonBind(intent: Intent): IBinder? { // A client is binding to the service with bindService() return binder } override funonUnbind(intent: Intent): Boolean { // All clients have unbound with unbindService() return allowRebind } override funonRebind(intent: Intent) { // A client is binding to the service with bindService(), // after onUnbind() has already been called } override funonDestroy() { // The service is no longer used and is being destroyed } }
Remarque : Contrairement aux méthodes de rappel du cycle de vie d'une activité, vous n'êtes pas obligé d'appeler l'implémentation de la super-classe de ces méthodes de rappel.
Figure 2. Le cycle de vie du service. Le diagramme de gauche montre le cycle de vie lorsque le service est créé avec startService(), et le diagramme de droite montre le cycle de vie lorsque le service est créé avec bindService().
La figure 2 illustre les méthodes de rappel standards d'un service. Bien que la figure sépare les services créés par startService() de ceux créés par bindService(), n'oubliez pas que tout service, quelle que soit la manière dont il est démarré, peut potentiellement permettre aux clients de s'y lier.
Un service initialement démarré avec onStartCommand() (par un client appelant startService()) peut toujours recevoir un appel à onBind() (lorsqu'un client appelle bindService()).
En implémentant ces méthodes, vous pouvez surveiller ces deux boucles imbriquées du cycle de vie du service :
- La durée de vie complète d'un service s'étend entre l'appel de
onCreate()et le renvoi deonDestroy(). Comme une activité, un service effectue sa configuration initiale dansonCreate()et libère toutes les ressources restantes dansonDestroy(). Par exemple, un service de lecture de musique peut créer le thread dans lequel la musique est lue dansonCreate(), puis l'arrêter dansonDestroy().Remarque : Les méthodes
onCreate()etonDestroy()sont appelées pour tous les services, qu'ils soient créés parstartService()oubindService(). - La durée de vie active d'un service commence par un appel à
onStartCommand()ouonBind(). Chaque méthode reçoit l'Intentqui a été transmis àstartService()oubindService().Si le service est démarré, la durée de vie active se termine en même temps que la durée de vie totale (le service est toujours actif même après le retour de
onStartCommand()). Si le service est lié, la durée de vie active se termine lorsqueonUnbind()est renvoyé.
Remarque : Bien qu'un service démarré soit arrêté par un appel à stopSelf() ou stopService(), il n'existe pas de rappel respectif pour le service (il n'y a pas de rappel onStop()). Sauf si le service est lié à un client, le système le détruit lorsqu'il est arrêté. onDestroy() est le seul rappel reçu.
Pour en savoir plus sur la création d'un service qui fournit une liaison, consultez le document Services liés, qui inclut des informations supplémentaires sur la méthode de rappel onRebind() dans la section Gérer le cycle de vie d'un service lié.