Langage de définition d'interface Android (AIDL)

Le langage AIDL (Android Interface Definition Language) est semblable aux autres IDL : il vous permet de définir l'interface de programmation convenue entre le client et le service afin de communiquer entre eux via la communication inter-processus (IPC).

Sur Android, un processus ne peut généralement pas accéder à la mémoire d'un autre processus. Pour communiquer, ils doivent décomposer leurs objets en primitives que le système d'exploitation peut comprendre et organiser les objets au-delà de cette limite pour vous. Le code permettant d'effectuer ce marshaling est fastidieux à écrire. Android s'en charge pour vous avec AIDL.

Remarque:AIDL n'est nécessaire que si vous permettez aux clients de différentes applications d'accéder à votre service pour l'IPC et que vous souhaitez gérer le multithreading dans votre service. Si vous n'avez pas besoin d'effectuer d'IPC simultanés entre différentes applications, créez votre interface en implémentant un Binder. Si vous souhaitez effectuer une communication inter-processus, mais que vous n'avez pas besoin de gérer le multithreading, implémentez votre interface à l'aide d'un Messenger. Quoi qu'il en soit, assurez-vous de bien comprendre les services liés avant d'implémenter un AIDL.

Avant de commencer à concevoir votre interface AIDL, sachez que les appels d'une interface AIDL sont des appels de fonction directs. Ne faites pas d'hypothèses sur le thread dans lequel l'appel a lieu. Le résultat varie selon que l'appel provient d'un thread du processus local ou d'un processus distant:

  • Les appels effectués à partir du processus local s'exécutent dans le même thread qui effectue l'appel. S'il s'agit de votre thread UI principal, ce thread continue de s'exécuter dans l'interface AIDL. S'il s'agit d'un autre thread, c'est celui qui exécute votre code dans le service. Ainsi, si seuls les threads locaux accèdent au service, vous pouvez contrôler entièrement les threads qui s'y exécutent. Toutefois, si tel est le cas, n'utilisez pas du tout AIDL. Créez plutôt l'interface en implémentant un Binder.
  • Les appels d'un processus distant sont distribués à partir d'un pool de threads géré par la plate-forme dans votre propre processus. Préparez-vous à recevoir des appels entrants provenant de threads inconnus, avec plusieurs appels simultanés. En d'autres termes, une implémentation d'une interface AIDL doit être complètement thread-safe. Les appels effectués à partir d'un thread sur le même objet distant arrivent dans l'ordre du côté du récepteur.
  • Le mot clé oneway modifie le comportement des appels à distance. Lorsqu'il est utilisé, un appel à distance ne bloque pas. Il envoie les données de transaction et renvoie immédiatement. L'implémentation de l'interface le reçoit à terme en tant qu'appel standard du pool de threads Binder en tant qu'appel distant normal. Si oneway est utilisé avec un appel local, il n'y a aucun impact et l'appel reste synchrone.

Définir une interface AIDL

Définissez votre interface AIDL dans un fichier .aidl à l'aide de la syntaxe du langage de programmation Java, puis enregistrez-la dans le code source, dans le répertoire src/, de l'application hébergeant le service et de toute autre application qui se lie au service.

Lorsque vous créez chaque application contenant le fichier .aidl, les outils du SDK Android génèrent une interface IBinder basée sur le fichier .aidl et l'enregistrent dans le répertoire gen/ du projet. Le service doit implémenter l'interface IBinder selon les besoins. Les applications clientes peuvent ensuite se lier au service et appeler des méthodes à partir de IBinder pour effectuer l'IPC.

Pour créer un service limité à l'aide d'AIDL, procédez comme suit, comme décrit dans les sections suivantes:

  1. Créer le fichier .aidl

    Ce fichier définit l'interface de programmation avec les signatures de méthode.

  2. Implémenter l'interface

    Les outils du SDK Android génèrent une interface en langage de programmation Java en fonction de votre fichier .aidl. Cette interface comporte une classe abstraite interne nommée Stub qui étend Binder et implémente les méthodes de votre interface AIDL. Vous devez étendre la classe Stub et implémenter les méthodes.

  3. Exposer l'interface aux clients

    Implémentez un Service et ignorez onBind() pour renvoyer votre implémentation de la classe Stub.

Attention:Toute modification que vous apportez à votre interface AIDL après votre première version doit rester rétrocompatible pour éviter de perturber d'autres applications qui utilisent votre service. En d'autres termes, étant donné que votre fichier .aidl doit être copié dans d'autres applications pour qu'elles puissent accéder à l'interface de votre service, vous devez maintenir la compatibilité avec l'interface d'origine.

Créer le fichier .aidl

AIDL utilise une syntaxe simple qui vous permet de déclarer une interface avec une ou plusieurs méthodes pouvant accepter des paramètres et des valeurs de retour. Les paramètres et les valeurs de retour peuvent être de n'importe quel type, même d'autres interfaces générées par AIDL.

Vous devez créer le fichier .aidl à l'aide du langage de programmation Java. Chaque fichier .aidl doit définir une interface unique, et ne nécessite que la déclaration de l'interface et les signatures de méthode.

Par défaut, AIDL prend en charge les types de données suivants:

  • Tous les types primitifs du langage de programmation Java (par exemple, int, long, char, boolean, etc.)
  • Tableaux de n'importe quel type, tels que int[] ou MyParcelable[]
  • String
  • CharSequence
  • List

    Tous les éléments de List doivent correspondre à l'un des types de données compatibles de cette liste ou à l'une des autres interfaces ou parcelables générées par AIDL que vous déclarez. Un List peut être utilisé en tant que classe de type paramétrée, comme List<String>. La classe concrète réelle que l'autre côté reçoit est toujours un ArrayList, bien que la méthode soit générée pour utiliser l'interface List.

  • Map

    Tous les éléments de Map doivent correspondre à l'un des types de données compatibles de cette liste ou à l'une des autres interfaces ou parcelables générées par AIDL que vous déclarez. Les mappages de types paramétrés, tels que ceux du formulaire Map<String,Integer>, ne sont pas acceptés. La classe concrète réelle que l'autre côté reçoit est toujours un HashMap, bien que la méthode soit générée pour utiliser l'interface Map. Envisagez d'utiliser un Bundle au lieu d'un Map.

Vous devez inclure une instruction import pour chaque type supplémentaire non listé précédemment, même s'il est défini dans le même package que votre interface.

Lorsque vous définissez l'interface de votre service, gardez à l'esprit les points suivants:

  • Les méthodes peuvent accepter zéro, un ou plusieurs paramètres, et renvoyer une valeur ou un vide.
  • Tous les paramètres non primitifs nécessitent une balise directionnelle indiquant la direction des données : in, out ou inout (voir l'exemple ci-dessous).

    Les primitives, String, IBinder et les interfaces générées par AIDL sont in par défaut et ne peuvent pas être autrement.

    Attention:Limitez la direction à ce qui est vraiment nécessaire, car les paramètres de marshalling sont coûteux.

  • Tous les commentaires de code inclus dans le fichier .aidl sont inclus dans l'interface IBinder générée, à l'exception des commentaires situés avant les instructions d'importation et de package.
  • Vous pouvez définir des constantes de chaîne et d'entier dans l'interface AIDL, par exemple const int VERSION = 1;.
  • Les appels de méthode sont distribués par un code transact(), qui est normalement basé sur un indice de méthode dans l'interface. Comme cela complique la gestion des versions, vous pouvez attribuer manuellement le code de transaction à une méthode: void method() = 10;.
  • Les arguments pouvant être de valeur nulle et les types renvoyés doivent être annotés à l'aide de @nullable.

Voici un exemple de fichier .aidl:

// IRemoteService.aidl
package com.example.android;

// Declare any non-default types here with import statements.

/** Example service interface */
interface IRemoteService {
    /** Request the process ID of this service. */
    int getPid();

    /** Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

Enregistrez votre fichier .aidl dans le répertoire src/ de votre projet. Lorsque vous compilez votre application, les outils du SDK génèrent le fichier d'interface IBinder dans le répertoire gen/ de votre projet. Le nom du fichier généré correspond à celui du fichier .aidl, mais avec une extension .java. Par exemple, IRemoteService.aidl génère IRemoteService.java.

Si vous utilisez Android Studio, la compilation incrémentielle génère la classe de liaison presque immédiatement. Si vous n'utilisez pas Android Studio, l'outil Gradle génère la classe de liaison la prochaine fois que vous compilez votre application. Compilez votre projet avec gradle assembleDebug ou gradle assembleRelease dès que vous avez terminé d'écrire le fichier .aidl, afin que votre code puisse être lié à la classe générée.

Implémenter l'interface

Lorsque vous compilez votre application, les outils du SDK Android génèrent un fichier d'interface .java nommé d'après votre fichier .aidl. L'interface générée inclut une sous-classe nommée Stub, qui est une implémentation abstraite de son interface parente, telle que YourInterface.Stub, et déclare toutes les méthodes du fichier .aidl.

Remarque:Stub définit également quelques méthodes d'assistance, en particulier asInterface(), qui prend un IBinder, généralement celui transmis à la méthode de rappel onServiceConnected() d'un client, et renvoie une instance de l'interface de bouchon. Pour en savoir plus sur cette conversion, consultez la section Appeler une méthode IPC.

Pour implémenter l'interface générée à partir de .aidl, étendez l'interface Binder générée, telle que YourInterface.Stub, et implémentez les méthodes héritées du fichier .aidl.

Voici un exemple d'implémentation d'une interface appelée IRemoteService, définie par l'exemple IRemoteService.aidl précédent, à l'aide d'une instance anonyme:

Kotlin

private val binder = object : IRemoteService.Stub() {

    override fun getPid(): Int =
            Process.myPid()

    override fun basicTypes(
            anInt: Int,
            aLong: Long,
            aBoolean: Boolean,
            aFloat: Float,
            aDouble: Double,
            aString: String
    ) {
        // Does nothing.
    }
}

Java

private final IRemoteService.Stub binder = new IRemoteService.Stub() {
    public int getPid(){
        return Process.myPid();
    }
    public void basicTypes(int anInt, long aLong, boolean aBoolean,
        float aFloat, double aDouble, String aString) {
        // Does nothing.
    }
};

binder est désormais une instance de la classe Stub (un Binder), qui définit l'interface IPC du service. À l'étape suivante, cette instance sera exposée aux clients pour qu'ils puissent interagir avec le service.

Tenez compte de quelques règles lorsque vous implémentez votre interface AIDL:

  • Il n'est pas garanti que les appels entrants s'exécutent sur le thread principal. Vous devez donc penser dès le début au multithreading et créer correctement votre service pour qu'il soit thread-safe.
  • Par défaut, les appels IPC sont synchrones. Si vous savez que le service prend plus de quelques millisecondes pour exécuter une requête, ne l'appelez pas à partir du thread principal de l'activité. Cela peut bloquer l'application, ce qui entraîne l'affichage d'une boîte de dialogue "L'application ne répond pas" par Android. Appelez-le à partir d'un thread distinct dans le client.
  • Seuls les types d'exceptions répertoriés dans la documentation de référence pour Parcel.writeException() sont renvoyés à l'appelant.

Exposer l'interface aux clients

Une fois que vous avez implémenté l'interface de votre service, vous devez l'exposer aux clients afin qu'ils puissent s'y associer. Pour exposer l'interface de votre service, étendez Service et implémentez onBind() afin de renvoyer une instance de votre classe qui implémente le Stub généré, comme indiqué dans la section précédente. Voici un exemple de service qui expose l'exemple d'interface IRemoteService aux clients.

Kotlin

class RemoteService : Service() {

    override fun onCreate() {
        super.onCreate()
    }

    override fun onBind(intent: Intent): IBinder {
        // Return the interface.
        return binder
    }


    private val binder = object : IRemoteService.Stub() {
        override fun getPid(): Int {
            return Process.myPid()
        }

        override fun basicTypes(
                anInt: Int,
                aLong: Long,
                aBoolean: Boolean,
                aFloat: Float,
                aDouble: Double,
                aString: String
        ) {
            // Does nothing.
        }
    }
}

Java

public class RemoteService extends Service {
    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        // Return the interface.
        return binder;
    }

    private final IRemoteService.Stub binder = new IRemoteService.Stub() {
        public int getPid(){
            return Process.myPid();
        }
        public void basicTypes(int anInt, long aLong, boolean aBoolean,
            float aFloat, double aDouble, String aString) {
            // Does nothing.
        }
    };
}

Désormais, lorsqu'un client, tel qu'une activité, appelle bindService() pour se connecter à ce service, le rappel onServiceConnected() du client reçoit l'instance binder renvoyée par la méthode onBind() du service.

Le client doit également avoir accès à la classe d'interface. Ainsi, si le client et le service se trouvent dans des applications distinctes, l'application du client doit disposer d'une copie du fichier .aidl dans son répertoire src/, qui génère l'interface android.os.Binder et permet au client d'accéder aux méthodes AIDL.

Lorsque le client reçoit le IBinder dans le rappel onServiceConnected(), il doit appeler YourServiceInterface.Stub.asInterface(service) pour caster le paramètre renvoyé au type YourServiceInterface:

Kotlin

var iRemoteService: IRemoteService? = null

val mConnection = object : ServiceConnection {

    // Called when the connection with the service is established.
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        // Following the preceding example for an AIDL interface,
        // this gets an instance of the IRemoteInterface, which we can use to call on the service.
        iRemoteService = IRemoteService.Stub.asInterface(service)
    }

    // Called when the connection with the service disconnects unexpectedly.
    override fun onServiceDisconnected(className: ComponentName) {
        Log.e(TAG, "Service has unexpectedly disconnected")
        iRemoteService = null
    }
}

Java

IRemoteService iRemoteService;
private ServiceConnection mConnection = new ServiceConnection() {
    // Called when the connection with the service is established.
    public void onServiceConnected(ComponentName className, IBinder service) {
        // Following the preceding example for an AIDL interface,
        // this gets an instance of the IRemoteInterface, which we can use to call on the service.
        iRemoteService = IRemoteService.Stub.asInterface(service);
    }

    // Called when the connection with the service disconnects unexpectedly.
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "Service has unexpectedly disconnected");
        iRemoteService = null;
    }
};

Pour obtenir d'autres exemples de code, consultez la classe RemoteService.java dans ApiDemos.

Transmettre des objets via IPC

Sous Android 10 (niveau d'API 29 ou version ultérieure), vous pouvez définir des objets Parcelable directement dans AIDL. Les types acceptés en tant qu'arguments d'interface AIDL et d'autres éléments parcellables sont également acceptés ici. Cela évite le travail supplémentaire d'écrire manuellement du code de marshalling et une classe personnalisée. Toutefois, cela crée également une struct nue. Si vous souhaitez utiliser des accesseurs personnalisés ou d'autres fonctionnalités, implémentez plutôt Parcelable.

package android.graphics;

// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect {
    int left;
    int top;
    int right;
    int bottom;
}

L'exemple de code précédent génère automatiquement une classe Java avec des champs d'entiers left, top, right et bottom. Tout le code de marshalling pertinent est implémenté automatiquement, et l'objet peut être utilisé directement sans avoir à ajouter d'implémentation.

Vous pouvez également envoyer une classe personnalisée d'un processus à un autre via une interface IPC. Toutefois, assurez-vous que le code de votre classe est disponible de l'autre côté du canal IPC et que votre classe doit être compatible avec l'interface Parcelable. La prise en charge de Parcelable est importante, car elle permet au système Android de décomposer des objets en primitives pouvant être marshallées entre les processus.

Pour créer une classe personnalisée compatible avec Parcelable, procédez comme suit:

  1. Faites en sorte que votre classe implémente l'interface Parcelable.
  2. Implémentez writeToParcel, qui prend l'état actuel de l'objet et l'écrit dans un Parcel.
  3. Ajoutez un champ statique appelé CREATOR à votre classe, qui est un objet implémentant l'interface Parcelable.Creator.
  4. Enfin, créez un fichier .aidl qui déclare votre classe parcelable, comme illustré dans le fichier Rect.aidl suivant.

    Si vous utilisez un processus de compilation personnalisé, n'ajoutez pas le fichier .aidl à votre compilation. Comme un fichier d'en-tête en langage C, ce fichier .aidl n'est pas compilé.

AIDL utilise ces méthodes et champs dans le code qu'il génère pour marshaller et démarshaller vos objets.

Par exemple, voici un fichier Rect.aidl permettant de créer une classe Rect parcelable:

package android.graphics;

// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect;

Voici un exemple de la façon dont la classe Rect implémente le protocole Parcelable.

Kotlin

import android.os.Parcel
import android.os.Parcelable

class Rect() : Parcelable {
    var left: Int = 0
    var top: Int = 0
    var right: Int = 0
    var bottom: Int = 0

    companion object CREATOR : Parcelable.Creator<Rect> {
        override fun createFromParcel(parcel: Parcel): Rect {
            return Rect(parcel)
        }

        override fun newArray(size: Int): Array<Rect?> {
            return Array(size) { null }
        }
    }

    private constructor(inParcel: Parcel) : this() {
        readFromParcel(inParcel)
    }

    override fun writeToParcel(outParcel: Parcel, flags: Int) {
        outParcel.writeInt(left)
        outParcel.writeInt(top)
        outParcel.writeInt(right)
        outParcel.writeInt(bottom)
    }

    private fun readFromParcel(inParcel: Parcel) {
        left = inParcel.readInt()
        top = inParcel.readInt()
        right = inParcel.readInt()
        bottom = inParcel.readInt()
    }

    override fun describeContents(): Int {
        return 0
    }
}

Java

import android.os.Parcel;
import android.os.Parcelable;

public final class Rect implements Parcelable {
    public int left;
    public int top;
    public int right;
    public int bottom;

    public static final Parcelable.Creator<Rect> CREATOR = new Parcelable.Creator<Rect>() {
        public Rect createFromParcel(Parcel in) {
            return new Rect(in);
        }

        public Rect[] newArray(int size) {
            return new Rect[size];
        }
    };

    public Rect() {
    }

    private Rect(Parcel in) {
        readFromParcel(in);
    }

    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(left);
        out.writeInt(top);
        out.writeInt(right);
        out.writeInt(bottom);
    }

    public void readFromParcel(Parcel in) {
        left = in.readInt();
        top = in.readInt();
        right = in.readInt();
        bottom = in.readInt();
    }

    public int describeContents() {
        return 0;
    }
}

Le marshaling dans la classe Rect est simple. Consultez les autres méthodes de Parcel pour découvrir les autres types de valeurs que vous pouvez écrire dans un Parcel.

Avertissement:N'oubliez pas les implications de sécurité de la réception de données à partir d'autres processus. Dans ce cas, Rect lit quatre chiffres à partir de Parcel, mais il vous incombe de vous assurer qu'ils se trouvent dans la plage de valeurs acceptables pour ce que l'appelant tente de faire. Pour en savoir plus sur la protection de votre application contre les logiciels malveillants, consultez les conseils de sécurité.

Méthodes avec des arguments Bundle contenant des Parcelables

Si une méthode accepte un objet Bundle qui doit contenir des éléments parcellables, assurez-vous de définir le chargeur de classe de l'Bundle en appelant Bundle.setClassLoader(ClassLoader) avant de tenter de lire à partir de l'Bundle. Sinon, vous rencontrez ClassNotFoundException, même si le parcelable est correctement défini dans votre application.

Prenons l'exemple de fichier .aidl suivant:

// IRectInsideBundle.aidl
package com.example.android;

/** Example service interface */
interface IRectInsideBundle {
    /** Rect parcelable is stored in the bundle with key "rect". */
    void saveRect(in Bundle bundle);
}
 Comme indiqué dans l'implémentation suivante, le ClassLoader est explicitement défini dans le Bundle avant la lecture de Rect:

Kotlin

private val binder = object : IRectInsideBundle.Stub() {
    override fun saveRect(bundle: Bundle) {
      bundle.classLoader = classLoader
      val rect = bundle.getParcelable<Rect>("rect")
      process(rect) // Do more with the parcelable.
    }
}

Java

private final IRectInsideBundle.Stub binder = new IRectInsideBundle.Stub() {
    public void saveRect(Bundle bundle){
        bundle.setClassLoader(getClass().getClassLoader());
        Rect rect = bundle.getParcelable("rect");
        process(rect); // Do more with the parcelable.
    }
};

Appeler une méthode IPC

Pour appeler une interface distante définie avec AIDL, procédez comme suit dans votre classe appelante:

  1. Incluez le fichier .aidl dans le répertoire src/ du projet.
  2. Déclarez une instance de l'interface IBinder, qui est générée en fonction de l'AIDL.
  3. Implémentez ServiceConnection.
  4. Appelez Context.bindService() en transmettant votre implémentation ServiceConnection.
  5. Dans votre implémentation de onServiceConnected(), vous recevez une instance IBinder, appelée service. Appelez YourInterfaceName.Stub.asInterface((IBinder)service) pour caster le paramètre renvoyé au type YourInterface.
  6. Appelez les méthodes que vous avez définies sur votre interface. Toujours intercepter les exceptions DeadObjectException, qui sont générées lorsque la connexion est interrompue. En outre, les exceptions SecurityException interceptent, qui sont levées lorsque les deux processus impliqués dans l'appel de méthode IPC ont des définitions AIDL en conflit.
  7. Pour vous déconnecter, appelez Context.unbindService() avec l'instance de votre interface.

Tenez compte des points suivants lorsque vous appelez un service IPC:

  • Le nombre de références aux objets est comptabilisé dans les processus.
  • Vous pouvez envoyer des objets anonymes en tant qu'arguments de méthode.

Pour en savoir plus sur l'association à un service, consultez la présentation des services liés.

Voici un exemple de code qui illustre l'appel d'un service créé par AIDL, tiré de l'exemple de service à distance du projet ApiDemos.

Kotlin

private const val BUMP_MSG = 1

class Binding : Activity() {

    /** The primary interface you call on the service.  */
    private var mService: IRemoteService? = null

    /** Another interface you use on the service.  */
    internal var secondaryService: ISecondary? = null

    private lateinit var killButton: Button
    private lateinit var callbackText: TextView
    private lateinit var handler: InternalHandler

    private var isBound: 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 is
            // established, giving us the service object we can use to
            // interact with the service.  We are communicating with our
            // service through an IDL interface, so get a client-side
            // representation of that from the raw service object.
            mService = IRemoteService.Stub.asInterface(service)
            killButton.isEnabled = true
            callbackText.text = "Attached."

            // We want to monitor the service for as long as we are
            // connected to it.
            try {
                mService?.registerCallback(mCallback)
            } catch (e: RemoteException) {
                // In this case, the service crashes before we can
                // do anything with it. We can count on soon being
                // disconnected (and then reconnected if it can be restarted)
                // so there is no need to do anything here.
            }

            // As part of the sample, tell the user what happened.
            Toast.makeText(
                    this@Binding,
                    R.string.remote_service_connected,
                    Toast.LENGTH_SHORT
            ).show()
        }

        override fun onServiceDisconnected(className: ComponentName) {
            // This is called when the connection with the service is
            // unexpectedly disconnected&mdash;that is, its process crashed.
            mService = null
            killButton.isEnabled = false
            callbackText.text = "Disconnected."

            // As part of the sample, tell the user what happened.
            Toast.makeText(
                    this@Binding,
                    R.string.remote_service_disconnected,
                    Toast.LENGTH_SHORT
            ).show()
        }
    }

    /**
     * Class for interacting with the secondary interface of the service.
     */
    private val secondaryConnection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // Connecting to a secondary interface is the same as any
            // other interface.
            secondaryService = ISecondary.Stub.asInterface(service)
            killButton.isEnabled = true
        }

        override fun onServiceDisconnected(className: ComponentName) {
            secondaryService = null
            killButton.isEnabled = false
        }
    }

    private val mBindListener = View.OnClickListener {
        // Establish a couple connections with the service, binding
        // by interface names. This lets other applications be
        // installed that replace the remote service by implementing
        // the same interface.
        val intent = Intent(this@Binding, RemoteService::class.java)
        intent.action = IRemoteService::class.java.name
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
        intent.action = ISecondary::class.java.name
        bindService(intent, secondaryConnection, Context.BIND_AUTO_CREATE)
        isBound = true
        callbackText.text = "Binding."
    }

    private val unbindListener = View.OnClickListener {
        if (isBound) {
            // If we have received the service, and hence registered with
            // it, then now is the time to unregister.
            try {
                mService?.unregisterCallback(mCallback)
            } catch (e: RemoteException) {
                // There is nothing special we need to do if the service
                // crashes.
            }

            // Detach our existing connection.
            unbindService(mConnection)
            unbindService(secondaryConnection)
            killButton.isEnabled = false
            isBound = false
            callbackText.text = "Unbinding."
        }
    }

    private val killListener = View.OnClickListener {
        // To kill the process hosting the service, we need to know its
        // PID.  Conveniently, the service has a call that returns
        // that information.
        try {
            secondaryService?.pid?.also { pid ->
                // Note that, though this API lets us request to
                // kill any process based on its PID, the kernel
                // still imposes standard restrictions on which PIDs you
                // can actually kill. Typically this means only
                // the process running your application and any additional
                // processes created by that app, as shown here. Packages
                // sharing a common UID are also able to kill each
                // other's processes.
                Process.killProcess(pid)
                callbackText.text = "Killed service process."
            }
        } catch (ex: RemoteException) {
            // Recover gracefully from the process hosting the
            // server dying.
            // For purposes of this sample, put up a notification.
            Toast.makeText(this@Binding, R.string.remote_call_failed, Toast.LENGTH_SHORT).show()
        }
    }

    // ----------------------------------------------------------------------
    // Code showing how to deal with callbacks.
    // ----------------------------------------------------------------------

    /**
     * This implementation is used to receive callbacks from the remote
     * service.
     */
    private val mCallback = object : IRemoteServiceCallback.Stub() {
        /**
         * This is called by the remote service regularly to tell us about
         * new values.  Note that IPC calls are dispatched through a thread
         * pool running in each process, so the code executing here is
         * NOT running in our main thread like most other things. So,
         * to update the UI, we need to use a Handler to hop over there.
         */
        override fun valueChanged(value: Int) {
            handler.sendMessage(handler.obtainMessage(BUMP_MSG, value, 0))
        }
    }

    /**
     * Standard initialization of this activity.  Set up the UI, then wait
     * for the user to interact with it before doing anything.
     */
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContentView(R.layout.remote_service_binding)

        // Watch for button taps.
        var button: Button = findViewById(R.id.bind)
        button.setOnClickListener(mBindListener)
        button = findViewById(R.id.unbind)
        button.setOnClickListener(unbindListener)
        killButton = findViewById(R.id.kill)
        killButton.setOnClickListener(killListener)
        killButton.isEnabled = false

        callbackText = findViewById(R.id.callback)
        callbackText.text = "Not attached."
        handler = InternalHandler(callbackText)
    }

    private class InternalHandler(
            textView: TextView,
            private val weakTextView: WeakReference<TextView> = WeakReference(textView)
    ) : Handler() {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                BUMP_MSG -> weakTextView.get()?.text = "Received from service: ${msg.arg1}"
                else -> super.handleMessage(msg)
            }
        }
    }
}

Java

public static class Binding extends Activity {
    /** The primary interface we are calling on the service. */
    IRemoteService mService = null;
    /** Another interface we use on the service. */
    ISecondary secondaryService = null;

    Button killButton;
    TextView callbackText;

    private InternalHandler handler;
    private boolean isBound;

    /**
     * Standard initialization of this activity. Set up the UI, then wait
     * for the user to interact with it before doing anything.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.remote_service_binding);

        // Watch for button taps.
        Button button = (Button)findViewById(R.id.bind);
        button.setOnClickListener(mBindListener);
        button = (Button)findViewById(R.id.unbind);
        button.setOnClickListener(unbindListener);
        killButton = (Button)findViewById(R.id.kill);
        killButton.setOnClickListener(killListener);
        killButton.setEnabled(false);

        callbackText = (TextView)findViewById(R.id.callback);
        callbackText.setText("Not attached.");
        handler = new InternalHandler(callbackText);
    }

    /**
     * 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 is
            // established, giving us the service object we can use to
            // interact with the service.  We are communicating with our
            // service through an IDL interface, so get a client-side
            // representation of that from the raw service object.
            mService = IRemoteService.Stub.asInterface(service);
            killButton.setEnabled(true);
            callbackText.setText("Attached.");

            // We want to monitor the service for as long as we are
            // connected to it.
            try {
                mService.registerCallback(mCallback);
            } catch (RemoteException e) {
                // In this case the service crashes before we can even
                // do anything with it. We can count on soon being
                // disconnected (and then reconnected if it can be restarted)
                // so there is no need to do anything here.
            }

            // As part of the sample, tell the user what happened.
            Toast.makeText(Binding.this, R.string.remote_service_connected,
                    Toast.LENGTH_SHORT).show();
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service is
            // unexpectedly disconnected&mdash;that is, its process crashed.
            mService = null;
            killButton.setEnabled(false);
            callbackText.setText("Disconnected.");

            // As part of the sample, tell the user what happened.
            Toast.makeText(Binding.this, R.string.remote_service_disconnected,
                    Toast.LENGTH_SHORT).show();
        }
    };

    /**
     * Class for interacting with the secondary interface of the service.
     */
    private ServiceConnection secondaryConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // Connecting to a secondary interface is the same as any
            // other interface.
            secondaryService = ISecondary.Stub.asInterface(service);
            killButton.setEnabled(true);
        }

        public void onServiceDisconnected(ComponentName className) {
            secondaryService = null;
            killButton.setEnabled(false);
        }
    };

    private OnClickListener mBindListener = new OnClickListener() {
        public void onClick(View v) {
            // Establish a couple connections with the service, binding
            // by interface names. This lets other applications be
            // installed that replace the remote service by implementing
            // the same interface.
            Intent intent = new Intent(Binding.this, RemoteService.class);
            intent.setAction(IRemoteService.class.getName());
            bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
            intent.setAction(ISecondary.class.getName());
            bindService(intent, secondaryConnection, Context.BIND_AUTO_CREATE);
            isBound = true;
            callbackText.setText("Binding.");
        }
    };

    private OnClickListener unbindListener = new OnClickListener() {
        public void onClick(View v) {
            if (isBound) {
                // If we have received the service, and hence registered with
                // it, then now is the time to unregister.
                if (mService != null) {
                    try {
                        mService.unregisterCallback(mCallback);
                    } catch (RemoteException e) {
                        // There is nothing special we need to do if the service
                        // crashes.
                    }
                }

                // Detach our existing connection.
                unbindService(mConnection);
                unbindService(secondaryConnection);
                killButton.setEnabled(false);
                isBound = false;
                callbackText.setText("Unbinding.");
            }
        }
    };

    private OnClickListener killListener = new OnClickListener() {
        public void onClick(View v) {
            // To kill the process hosting our service, we need to know its
            // PID.  Conveniently, our service has a call that returns
            // that information.
            if (secondaryService != null) {
                try {
                    int pid = secondaryService.getPid();
                    // Note that, though this API lets us request to
                    // kill any process based on its PID, the kernel
                    // still imposes standard restrictions on which PIDs you
                    // can actually kill.  Typically this means only
                    // the process running your application and any additional
                    // processes created by that app as shown here. Packages
                    // sharing a common UID are also able to kill each
                    // other's processes.
                    Process.killProcess(pid);
                    callbackText.setText("Killed service process.");
                } catch (RemoteException ex) {
                    // Recover gracefully from the process hosting the
                    // server dying.
                    // For purposes of this sample, put up a notification.
                    Toast.makeText(Binding.this,
                            R.string.remote_call_failed,
                            Toast.LENGTH_SHORT).show();
                }
            }
        }
    };

    // ----------------------------------------------------------------------
    // Code showing how to deal with callbacks.
    // ----------------------------------------------------------------------

    /**
     * This implementation is used to receive callbacks from the remote
     * service.
     */
    private IRemoteServiceCallback mCallback = new IRemoteServiceCallback.Stub() {
        /**
         * This is called by the remote service regularly to tell us about
         * new values.  Note that IPC calls are dispatched through a thread
         * pool running in each process, so the code executing here is
         * NOT running in our main thread like most other things. So,
         * to update the UI, we need to use a Handler to hop over there.
         */
        public void valueChanged(int value) {
            handler.sendMessage(handler.obtainMessage(BUMP_MSG, value, 0));
        }
    };

    private static final int BUMP_MSG = 1;

    private static class InternalHandler extends Handler {
        private final WeakReference<TextView> weakTextView;

        InternalHandler(TextView textView) {
            weakTextView = new WeakReference<>(textView);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case BUMP_MSG:
                    TextView textView = weakTextView.get();
                    if (textView != null) {
                        textView.setText("Received from service: " + msg.arg1);
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
}