Un service lié est le serveur dans une interface client-serveur. Il permet aux composants comme la liaison au service, l'envoi de requêtes, la réception de réponses et l'exécution la communication inter-processus (IPC). En général, un service lié ne vit que s'il est au service d'un autre composant d'application et ne s'exécute pas indéfiniment en arrière-plan.
Ce document explique comment créer un service lié et lier au service à partir d'autres composants d'application. Pour en savoir plus sur les services d'ordre général, comme l'envoi de notifications à partir d'un service et l'exécution de celui-ci au premier plan, consultez la section Présentation des services
Principes de base
Un service lié est une implémentation de la classe Service
qui permet
d'autres applications s'y lient et interagissent avec lui. Pour fournir la liaison d'un
vous implémentez la méthode de rappel onBind()
. Ce
La méthode renvoie un objet IBinder
qui définit l'interface de programmation qui
les clients peuvent utiliser
pour interagir avec le service.
Associer à un service démarré
Comme indiqué dans la présentation des services,
vous pouvez créer un service qui est à la fois démarré et lié. Autrement dit, vous pouvez
service en appelant startService()
, ce qui permet
service s'exécute indéfiniment. Vous pouvez également laisser
un client s'associer au service en
Appel de bindService()
en cours.
Si vous laissez votre service être démarré
et lié, alors au démarrage du service,
le système ne détruit pas le service lorsque tous les clients sont dissociés.
À la place, vous devez
arrêter explicitement le service en appelant stopSelf()
ou stopService()
.
Bien que vous implémentiez généralement onBind()
ou onStartCommand()
, il est parfois
nécessaires pour
mettre en œuvre les deux. Par exemple, un lecteur de musique peut trouver utile de laisser son service fonctionner
indéfiniment et fournissent également une liaison. Ainsi, une activité peut lancer le service pour lire des
et la musique continue même si l'utilisateur quitte l'application. Ensuite, lorsque l’utilisateur
à l'application, l'activité peut s'associer au service pour reprendre le contrôle
lecture.
Pour en savoir plus sur le cycle de vie d'un service lors de l'ajout d'une liaison à un service démarré, consultez la section Gérer le cycle de vie d'un service lié.
Un client se lie à un service en appelant
bindService()
Lorsque c'est le cas, il doit
fournissent une implémentation de ServiceConnection
, qui
surveille la connexion au service. La valeur renvoyée pour
bindService()
indique si le
le service demandé existe et si
le client est autorisé à y accéder.
Quand ?
le système Android crée la connexion entre le client et le service,
appelle onServiceConnected()
le ServiceConnection
. La
La méthode onServiceConnected()
inclut un élément IBinder
que le client utilise ensuite pour communiquer avec le service lié.
Vous pouvez connecter plusieurs clients à un service simultanément. Toutefois,
le système met en cache le canal de communication du service IBinder
.
En d'autres termes, le système appelle la méthode onBind()
du service
pour générer l'IBinder
uniquement lorsque la première
et des liaisons client externes. Le système envoie ensuite ce même IBinder
à
tous les clients supplémentaires qui se rattachent à ce même service, sans appeler
onBind()
.
Lorsque le dernier client se dissocie du service, le système le détruit, à moins que le
service a été démarré avec startService()
.
La partie la plus importante de l'implémentation de votre service lié consiste à définir l'interface
renvoyé par votre méthode de rappel onBind()
. Les éléments suivants :
présente plusieurs façons de définir le service
IBinder
.
Créer un service lié
Lorsque vous créez un service fournissant une liaison, vous devez indiquer un IBinder
qui fournit l'interface de programmation
que les clients peuvent utiliser pour interagir avec le service. Il y
vous pouvez définir l'interface de trois façons:
- Étendre la classe Binder
- Si votre service est réservé à votre propre application et s'exécute dans le même processus
en tant que client, ce qui est courant, créez votre interface en étendant
Binder
cours et en renvoyant une instanceonBind()
Le client reçoit lesBinder
et peut l'utiliser pour accéder directement aux méthodes publiques disponibles dansBinder
ou laService
.Il s'agit de la technique à privilégier lorsque votre service est simplement un nœud de calcul d'arrière-plan pour votre propre application. Le seul cas d'utilisation où il ne s'agit pas de la méthode privilégiée pour créer votre interface est si votre service est utilisé par d'autres applications ou dans des processus distincts.
- Utiliser Messenger
- Si vous avez besoin que votre interface soit compatible avec différents processus, vous pouvez créer
une interface pour le service avec un
Messenger
. De cette manière, le service Définit unHandler
qui répond à différents types d'objetsMessage
.Ce/Cet/Cette
Handler
est la base d'unMessenger
qui peut ensuite partager unIBinder
. avec le client, ce qui lui permet d'envoyer des commandes au service à l'aide d'objetsMessage
. De plus, le client peut définir unMessenger
afin que le service puisse renvoyer des messages.Il s'agit du moyen le plus simple d'effectuer une communication inter-processus (IPC), car
Messenger
met toutes les requêtes en file d'attente dans un seul thread afin que vous n'ayez pas à concevoir de sorte qu'il soit sécurisé. - Utiliser AIDL
- Le langage AIDL (Android Interface Definition Language) décompose les objets en
primitives que le système d'exploitation peut comprendre, et les regroupe entre les processus afin d'effectuer
IPC. La technique précédente, qui utilise un
Messenger
, est en fait basée sur AIDL en tant que sa structure sous-jacente.Comme indiqué dans la section précédente,
Messenger
crée une file d'attente de toutes les requêtes des clients dans un seul thread, de sorte que le service reçoit les requêtes une par une. Si, Toutefois, si vous souhaitez que votre service traite plusieurs requêtes simultanément, vous pouvez utiliser AIDL directement. Dans ce cas, votre service doit être thread-safe et compatible avec le multithreading.Pour utiliser AIDL directement, Créez un fichier
.aidl
qui définit l'interface de programmation. Les SDK Tools pour Android utilisent ce fichier pour générer une classe abstraite qui implémente l'interface et gère l'IPC, que vous pouvez que vous pouvez étendre au sein de votre service.
Remarque:Pour la plupart des applications, AIDL n'est pas le meilleur choix pour créer un service lié, car il peut nécessiter des fonctionnalités de multithreading et peut entraîner une implémentation plus compliquée. Par conséquent, ce document n'aborde pas la façon dont pour l'utiliser pour votre service. Si vous êtes certain d'avoir besoin pour utiliser AIDL directement, consultez le document AIDL document.
Étendre la classe Binder
Si seule l'application locale utilise votre service et qu'elle n'a pas besoin
travailler sur plusieurs processus,
vous pouvez implémenter votre propre classe Binder
, qui fournit directement à votre client
aux méthodes publiques du service.
Remarque:Cela ne fonctionne que si le client et le service font partie du même l'application et le processus, ce qui est le plus courant. Par exemple, cela fonctionne bien pour une musique application qui doit lier une activité à son propre service qui lit de la musique dans en arrière-plan.
Voici comment faire :
- Dans votre service, créez une instance de
Binder
qui effectue l'une des options suivantes: <ph type="x-smartling-placeholder">- </ph>
- Contient des méthodes publiques que le client peut appeler.
- Renvoie l'instance
Service
actuelle, qui comporte des méthodes publiques que le client peut appeler. - Renvoie une instance d'une autre classe hébergée par le service avec des méthodes publiques que la que le client peut appeler.
- Renvoyez cette instance de
Binder
à partir de la méthode de rappelonBind()
. - Dans le client, recevez
Binder
à partir de la méthode de rappelonServiceConnected()
. appeler le service lié à l'aide des méthodes fournies.
Remarque:Le service et le client doivent être dans le même afin que le client puisse caster l'objet renvoyé et appeler correctement ses API. Le service et le client doivent aussi être dans le même processus, car cette technique n'effectue le marshaling entre les processus.
Par exemple, voici un service qui permet aux clients d'accéder aux méthodes du service via
Une implémentation de Binder
:
Kotlin
class LocalService : Service() { // Binder given to clients. private val binder = LocalBinder() // Random number generator. private val mGenerator = Random() /** Method for clients. */ val randomNumber: Int get() = mGenerator.nextInt(100) /** * Class used for the client Binder. Because we know this service always * runs in the same process as its clients, we don't need to deal with IPC. */ inner class LocalBinder : Binder() { // Return this instance of LocalService so clients can call public methods. fun getService(): LocalService = this@LocalService } override fun onBind(intent: Intent): IBinder { return binder } }
Java
public class LocalService extends Service { // Binder given to clients. private final IBinder binder = new LocalBinder(); // Random number generator. private final Random mGenerator = new Random(); /** * Class used for the client Binder. Because we know this service always * runs in the same process as its clients, we don't need to deal with IPC. */ public class LocalBinder extends Binder { LocalService getService() { // Return this instance of LocalService so clients can call public methods. return LocalService.this; } } @Override public IBinder onBind(Intent intent) { return binder; } /** Method for clients. */ public int getRandomNumber() { return mGenerator.nextInt(100); } }
LocalBinder
fournit la méthode getService()
aux clients pour qu'ils récupèrent
l'instance actuelle de LocalService
. Cela permet aux clients d'appeler des méthodes publiques
Google Cloud. Par exemple, les clients peuvent appeler getRandomNumber()
à partir du service.
Voici une activité qui se lie à LocalService
et appelle getRandomNumber()
lorsqu'un utilisateur clique sur un bouton:
Kotlin
class BindingActivity : Activity() { private lateinit var mService: LocalService private var mBound: Boolean = false /** Defines callbacks for service binding, passed to bindService(). */ private val connection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // We've bound to LocalService, cast the IBinder and get LocalService instance. val binder = service as LocalService.LocalBinder mService = binder.getService() mBound = true } override fun onServiceDisconnected(arg0: ComponentName) { mBound = false } } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.main) } override fun onStart() { super.onStart() // Bind to LocalService. Intent(this, LocalService::class.java).also { intent -> bindService(intent, connection, Context.BIND_AUTO_CREATE) } } override fun onStop() { super.onStop() unbindService(connection) mBound = false } /** Called when a button is clicked (the button in the layout file attaches to * this method with the android:onClick attribute). */ fun onButtonClick(v: View) { if (mBound) { // Call a method from the LocalService. // However, if this call is something that might hang, then put this request // in a separate thread to avoid slowing down the activity performance. val num: Int = mService.randomNumber Toast.makeText(this, "number: $num", Toast.LENGTH_SHORT).show() } } }
Java
public class BindingActivity extends Activity { LocalService mService; boolean mBound = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override protected void onStart() { super.onStart(); // Bind to LocalService. Intent intent = new Intent(this, LocalService.class); bindService(intent, connection, Context.BIND_AUTO_CREATE); } @Override protected void onStop() { super.onStop(); unbindService(connection); mBound = false; } /** Called when a button is clicked (the button in the layout file attaches to * this method with the android:onClick attribute). */ public void onButtonClick(View v) { if (mBound) { // Call a method from the LocalService. // However, if this call is something that might hang, then put this request // in a separate thread to avoid slowing down the activity performance. int num = mService.getRandomNumber(); Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show(); } } /** Defines callbacks for service binding, passed to bindService(). */ private ServiceConnection connection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName className, IBinder service) { // We've bound to LocalService, cast the IBinder and get LocalService instance. LocalBinder binder = (LocalBinder) service; mService = binder.getService(); mBound = true; } @Override public void onServiceDisconnected(ComponentName arg0) { mBound = false; } }; }
L'exemple précédent montre comment le client se lie au service en utilisant une implémentation de
ServiceConnection
et le rappel onServiceConnected()
. La prochaine
fournit plus d'informations sur ce processus de liaison au service.
Remarque:Dans l'exemple précédent, le
La méthode onStop()
dissocie le client du service.
Dissociez les clients des services au moment opportun, comme indiqué dans les
Remarques supplémentaires.
Pour plus d'exemples de code, consultez le
LocalService.java
et
LocalServiceActivities.java
dans ApiDemos.
Utiliser Chat +
Si vous avez besoin que votre service communique avec des processus distants, vous pouvez utiliser un
Messenger
pour fournir l'interface de votre service. Cette technique permet
d'effectuer une communication inter-processus (IPC) sans avoir besoin d'utiliser AIDL.
L'utilisation d'un Messenger
pour votre interface est
plus simple que d'utiliser AIDL, car les files d'attente Messenger
tous les appels au service. Une interface AIDL pure envoie des requêtes simultanées au
qui doit ensuite gérer le multithreading.
Pour la plupart des applications, le service n'a pas besoin d'effectuer un multithreading. Par conséquent, l'utilisation d'un Messenger
lui permet de gérer un appel à la fois. Si c'est important
que votre service soit multithread, utilisez AIDL pour définir votre interface.
Voici un récapitulatif de l'utilisation d'un Messenger
:
- Le service implémente un
Handler
qui reçoit un rappel pour chaque de la part d'un client. - Le service utilise
Handler
pour créer unMessenger
. objet (qui est une référence àHandler
). Messenger
crée unIBinder
que le service les retours aux clients à partir duonBind()
.- Les clients utilisent
IBinder
pour instancierMessenger
(qui fait référence auHandler
du service), que le client utilise pour envoyerMessage
au service. - Le service reçoit chaque
Message
dans sonHandler
, plus précisément dans la méthodehandleMessage()
.
Ainsi, le client n'a pas de méthode à appeler sur le service. L'élément
le client fournit les messages (objets Message
) que le service
reçoit dans
son Handler
.
Voici un exemple de service simple qui utilise une interface Messenger
:
Kotlin
/** Command to the service to display a message. */ private const val MSG_SAY_HELLO = 1 class MessengerService : Service() { /** * Target we publish for clients to send messages to IncomingHandler. */ private lateinit var mMessenger: Messenger /** * Handler of incoming messages from clients. */ internal class IncomingHandler( context: Context, private val applicationContext: Context = context.applicationContext ) : Handler() { override fun handleMessage(msg: Message) { when (msg.what) { MSG_SAY_HELLO -> Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show() else -> super.handleMessage(msg) } } } /** * When binding to the service, we return an interface to our messenger * for sending messages to the service. */ override fun onBind(intent: Intent): IBinder? { Toast.makeText(applicationContext, "binding", Toast.LENGTH_SHORT).show() mMessenger = Messenger(IncomingHandler(this)) return mMessenger.binder } }
Java
public class MessengerService extends Service { /** * Command to the service to display a message. */ static final int MSG_SAY_HELLO = 1; /** * Handler of incoming messages from clients. */ static class IncomingHandler extends Handler { private Context applicationContext; IncomingHandler(Context context) { applicationContext = context.getApplicationContext(); } @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_SAY_HELLO: Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show(); break; default: super.handleMessage(msg); } } } /** * Target we publish for clients to send messages to IncomingHandler. */ Messenger mMessenger; /** * When binding to the service, we return an interface to our messenger * for sending messages to the service. */ @Override public IBinder onBind(Intent intent) { Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show(); mMessenger = new Messenger(new IncomingHandler(this)); return mMessenger.getBinder(); } }
La méthode handleMessage()
dans
Handler
est l'endroit où le service reçoit les Message
entrantes
et décide quoi faire en fonction du membre what
.
Un client n'a qu'à créer un Messenger
basé sur le IBinder
renvoyé par le service et à envoyer un message à l'aide de send()
. Par exemple, voici une activité qui se lie au
service et transmet le message MSG_SAY_HELLO
au service:
Kotlin
class ActivityMessenger : Activity() { /** Messenger for communicating with the service. */ private var mService: Messenger? = null /** Flag indicating whether we have called bind on the service. */ private var bound: Boolean = false /** * Class for interacting with the main interface of the service. */ private val mConnection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // This is called when the connection with the service has been // established, giving us the object we can use to // interact with the service. We are communicating with the // service using a Messenger, so here we get a client-side // representation of that from the raw IBinder object. mService = Messenger(service) bound = true } override fun onServiceDisconnected(className: ComponentName) { // This is called when the connection with the service has been // unexpectedly disconnected—that is, its process crashed. mService = null bound = false } } fun sayHello(v: View) { if (!bound) return // Create and send a message to the service, using a supported 'what' value. val msg: Message = Message.obtain(null, MSG_SAY_HELLO, 0, 0) try { mService?.send(msg) } catch (e: RemoteException) { e.printStackTrace() } } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.main) } override fun onStart() { super.onStart() // Bind to the service. Intent(this, MessengerService::class.java).also { intent -> bindService(intent, mConnection, Context.BIND_AUTO_CREATE) } } override fun onStop() { super.onStop() // Unbind from the service. if (bound) { unbindService(mConnection) bound = false } } }
Java
public class ActivityMessenger extends Activity { /** Messenger for communicating with the service. */ Messenger mService = null; /** Flag indicating whether we have called bind on the service. */ boolean bound; /** * Class for interacting with the main interface of the service. */ private ServiceConnection mConnection = new ServiceConnection() { public void onServiceConnected(ComponentName className, IBinder service) { // This is called when the connection with the service has been // established, giving us the object we can use to // interact with the service. We are communicating with the // service using a Messenger, so here we get a client-side // representation of that from the raw IBinder object. mService = new Messenger(service); bound = true; } public void onServiceDisconnected(ComponentName className) { // This is called when the connection with the service has been // unexpectedly disconnected—that is, its process crashed. mService = null; bound = false; } }; public void sayHello(View v) { if (!bound) return; // Create and send a message to the service, using a supported 'what' value. Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0); try { mService.send(msg); } catch (RemoteException e) { e.printStackTrace(); } } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override protected void onStart() { super.onStart(); // Bind to the service. bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE); } @Override protected void onStop() { super.onStop(); // Unbind from the service. if (bound) { unbindService(mConnection); bound = false; } } }
Cet exemple ne montre pas comment le service peut répondre au client.
Si vous souhaitez que
service pour répondre, vous devez également créer un Messenger
dans le client.
Lorsque le client reçoit le rappel onServiceConnected()
, il envoie un Message
au service qui inclut
La valeur Messenger
du client dans le paramètre replyTo
de la méthode send()
.
Vous trouverez un exemple de communication bidirectionnelle dans le
MessengerService.java
(service) et
Échantillons MessengerServiceActivities.java
(client).
Associer à un service
Les composants d'application (clients) peuvent s'associer à un service en appelant
bindService()
Android
système appelle ensuite la méthode onBind()
du service, qui renvoie un IBinder
pour interagir avec
le service.
La liaison est asynchrone, et bindService()
renvoie immédiatement un résultat sans renvoyer IBinder
à
le client. Pour recevoir le IBinder
, le client doit créer un
une instance de ServiceConnection
et la transmettre à bindService()
. ServiceConnection
inclut une méthode de rappel que le
d'appels système pour fournir le IBinder
.
Remarque:Seuls les fournisseurs de contenu, d'activités et de services peuvent être contraints à un service, vous ne pouvez pas établir de lien avec un service à partir d'un broadcast receiver.
Pour créer une association à un service depuis votre client, procédez comme suit:
- Implémentez
ServiceConnection
.Votre implémentation doit remplacer deux méthodes de rappel:
onServiceConnected()
- Le système l'appelle pour fournir le
IBinder
renvoyé par la méthodeonBind()
du service. onServiceDisconnected()
- Le système Android appelle cette méthode lorsque la connexion au service est inattendue. par exemple en cas de plantage ou d'arrêt du service. Il ne s'agit pas appelé lorsque le est dissociée.
- Appelez
bindService()
en transmettant l'implémentationServiceConnection
.Remarque:Si la méthode renvoie "false", votre ne dispose pas d'une connexion valide au service. En revanche, appelez
unbindService()
dans votre client. Sinon, votre client empêche le service s'éteindre lorsqu'il est inactif. - Lorsque le système appelle votre méthode de rappel
onServiceConnected()
, vous pouvez commencer à appeler le service en utilisant les méthodes définies par l'interface. - Pour vous déconnecter du service, appelez
unbindService()
.Si votre client est toujours lié à un service lorsque votre application le détruit, entraîne la dissociation du client. Il est préférable de dissocier le client dès que cela est terminé. interagissant avec le service. Cela permet au service inactif de s'arrêter. Pour en savoir plus, pour connaître les moments opportuns pour associer et annuler la liaison, consultez la section Remarques supplémentaires.
L'exemple suivant connecte le client au service créé précédemment par
extension de la classe Binder. Il lui suffit donc de caster les valeurs renvoyées
IBinder
à la classe LocalBinder
et demandez l'instance LocalService
:
Kotlin
var mService: LocalService val mConnection = object : ServiceConnection { // Called when the connection with the service is established. override fun onServiceConnected(className: ComponentName, service: IBinder) { // Because we have bound to an explicit // service that is running in our own process, we can // cast its IBinder to a concrete class and directly access it. val binder = service as LocalService.LocalBinder mService = binder.getService() mBound = true } // Called when the connection with the service disconnects unexpectedly. override fun onServiceDisconnected(className: ComponentName) { Log.e(TAG, "onServiceDisconnected") mBound = false } }
Java
LocalService mService; private ServiceConnection mConnection = new ServiceConnection() { // Called when the connection with the service is established. public void onServiceConnected(ComponentName className, IBinder service) { // Because we have bound to an explicit // service that is running in our own process, we can // cast its IBinder to a concrete class and directly access it. LocalBinder binder = (LocalBinder) service; mService = binder.getService(); mBound = true; } // Called when the connection with the service disconnects unexpectedly. public void onServiceDisconnected(ComponentName className) { Log.e(TAG, "onServiceDisconnected"); mBound = false; } };
Avec ce ServiceConnection
, le client peut s'associer à un service
en transmettant
en bindService()
, comme illustré dans l'exemple suivant:
Kotlin
Intent(this, LocalService::class.java).also { intent -> bindService(intent, connection, Context.BIND_AUTO_CREATE) }
Java
Intent intent = new Intent(this, LocalService.class); bindService(intent, connection, Context.BIND_AUTO_CREATE);
- Le premier paramètre de
bindService()
est unIntent
qui nomme explicitement le service à lier.Attention:Si vous utilisez un intent pour créer une liaison
Service
, assurez-vous que votre application est sécurisée à l'aide d'un élément explicite. l'intention. L'utilisation d'un intent implicite pour démarrer un service de sécurité, car vous ne pouvez pas savoir quel service répond à 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 appelezbindService()
. avec un intent implicite. - Le deuxième paramètre est l'objet
ServiceConnection
. - Le troisième paramètre est une option indiquant les options de liaison (généralement
BIND_AUTO_CREATE
) permettant de créer le service si ce n'est pas déjà fait vivant. Les autres valeurs possibles sontBIND_DEBUG_UNBIND
,BIND_NOT_FOREGROUND
ou0
pour aucune donnée.
Remarques supplémentaires
Voici quelques remarques importantes concernant la liaison à un service:
- Pimentez toujours les exceptions
DeadObjectException
, qui sont générées. lorsque la connexion est interrompue. Il s'agit de la seule exception générée par les méthodes distantes. - Les objets sont comptabilisés comme des références dans tous les processus.
- Vous associez généralement la liaison et la dissociation au cours de l'
les moments de mise en service et de suppression correspondants du cycle de vie du client, comme décrit dans le
les exemples suivants:
<ph type="x-smartling-placeholder">
- </ph>
- Si vous ne devez interagir avec le service que lorsque votre activité est visible, associez-la pendant
onStart()
et dissociez-la pendantonStop()
. - Si vous souhaitez que votre activité reçoive des réponses même lorsqu'elle est arrêtée dans
arrière-plan, liaison pendant
onCreate()
et désassociation pendantonDestroy()
. Gardez à l'esprit que cela implique doit utiliser le service pendant toute sa durée d'exécution, même en arrière-plan. Ainsi, le service est dans un autre processus, alors vous augmentez la pondération du processus, plus de chances d’être tuées par le système.
Remarque:En général, vous ne liez pas et ne la dissociez pas. pendant les rappels
onResume()
etonPause()
de votre activité, car ces rappels se produisent à chaque du cycle de vie de la solution. Réduisez au minimum le traitement effectué lors de ces transitions.Par ailleurs, si plusieurs activités de votre application sont liées au même service transition entre deux de ces activités, le service peut être détruit et recréé dissociations d'activités (lors d'une pause) avant que la suivante ne soit liée (lors de la reprise). Cette transition d'activité pour savoir comment coordonnent leur cycle de vie est décrit dans la section Cycle de vie d'une activité.
- Si vous ne devez interagir avec le service que lorsque votre activité est visible, associez-la pendant
Pour obtenir d'autres exemples de code montrant comment créer une liaison à un service, consultez la
RemoteService.java
dans ApiDemos.
Gérer le cycle de vie d'un service lié
Lorsqu'un service est dissocié de tous les clients, le système Android le détruit
(sauf si elle a été lancée avec
startService()
).
Vous n'avez donc pas à gérer le cycle de vie de votre service
uniquement un service lié. Le système Android le gère pour vous en fonction
s'il est lié à des clients.
Toutefois, si vous choisissez d'implémenter la méthode de rappel onStartCommand()
, vous devez arrêter explicitement le service, car le
est maintenant considéré comme démarré. Dans ce cas, le service s'exécute jusqu'à ce qu'il
s'arrête avec stopSelf()
ou un autre composant appelle stopService()
, qu'il soit lié ou non à
clients.
De plus, si votre service est démarré et accepte la liaison, lorsque le système appelle
votre méthode onUnbind()
, vous pouvez éventuellement renvoyer
true
si vous souhaitez recevoir un appel à onRebind()
la prochaine fois qu'un client s'associe au service. onRebind()
renvoie une valeur nulle, mais le client reçoit toujours le IBinder
dans son
onServiceConnected()
.
La figure suivante illustre la logique pour ce type de cycle de vie.
![](https://developer.android.google.cn/static/images/fundamentals/service_binding_tree_lifecycle.png?authuser=19&hl=fr)
Figure 1 : Cycle de vie d'un service démarré et autorise également la liaison.
Pour en savoir plus sur le cycle de vie d'un service en cours de démarrage, consultez la Présentation des services.