Présentation des services liés

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 instance onBind() Le client reçoit les Binder et peut l'utiliser pour accéder directement aux méthodes publiques disponibles dans Binder ou la Service.

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 un Handler qui répond à différents types d'objets Message.

Ce/Cet/Cette Handler est la base d'un Messenger qui peut ensuite partager un IBinder. avec le client, ce qui lui permet d'envoyer des commandes au service à l'aide d'objets Message. De plus, le client peut définir un Messenger 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 :

  1. 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.
  2. Renvoyez cette instance de Binder à partir de la méthode de rappel onBind().
  3. Dans le client, recevez Binder à partir de la méthode de rappel onServiceConnected(). 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:

  1. Le service implémente un Handler qui reçoit un rappel pour chaque de la part d'un client.
  2. Le service utilise Handler pour créer un Messenger. objet (qui est une référence à Handler).
  3. Messenger crée un IBinder que le service les retours aux clients à partir du onBind().
  4. Les clients utilisent IBinder pour instancier Messenger (qui fait référence au Handler du service), que le client utilise pour envoyer Message au service.
  5. Le service reçoit chaque Message dans son Handler, plus précisément dans la méthode handleMessage().

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&mdash;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&mdash;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:

  1. 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éthode onBind() 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.
  2. Appelez bindService() en transmettant l'implémentation ServiceConnection.

    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.

  3. 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.
  4. 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 un Intent 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 appelez bindService(). 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 sont BIND_DEBUG_UNBIND, BIND_NOT_FOREGROUND ou 0 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 pendant onStop().
    • 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 pendant onDestroy(). 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() et onPause() 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é.

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.

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.