Android Interface Definition Language (AIDL)

Die Android Interface-Definitionssprache (AIDL) ähnelt anderen IDLs: Sie ermöglicht es Ihnen, die Programmierschnittstelle zu definieren, auf die sich sowohl der Client als auch der Dienst einigen, um über Interprocess Communication (IPC) miteinander zu kommunizieren.

Unter Android kann ein Prozess normalerweise nicht auf den Arbeitsspeicher eines anderen Prozesses zugreifen. Damit sie miteinander kommunizieren können, müssen sie ihre Objekte in Primitive zerlegen, die das Betriebssystem verstehen kann, und die Objekte für Sie über diese Grenze hinweg marshallen. Der Code für dieses Marshalling ist mühsam zu schreiben, daher übernimmt Android das mit AIDL für dich.

Hinweis: AIDL ist nur erforderlich, wenn du Clients aus verschiedenen Anwendungen den Zugriff auf deinen Dienst für die IPC erlaubst und Multithreading in deinem Dienst verarbeiten möchtest. Wenn Sie keine gleichzeitige IPC über verschiedene Anwendungen hinweg ausführen müssen, erstellen Sie Ihre Schnittstelle, indem Sie eine Binder implementieren. Wenn du IPC ausführen möchtest, aber kein Multithreading benötigst, implementiere deine Schnittstelle mit einem Messenger. Unabhängig davon sollten Sie sich mit gebundenen Diensten vertraut machen, bevor Sie eine AIDL implementieren.

Bevor Sie mit dem Entwerfen Ihrer AIDL-Schnittstelle beginnen, sollten Sie sich bewusst sein, dass Aufrufe einer AIDL-Schnittstelle direkte Funktionsaufrufe sind. Gehen Sie nicht davon aus, dass der Aufruf in einem bestimmten Thread erfolgt. Was passiert, hängt davon ab, ob der Aufruf von einem Thread im lokalen Prozess oder einem Remote-Prozess stammt:

  • Aufrufe, die vom lokalen Prozess ausgeführt werden, werden im selben Thread ausgeführt, der den Aufruf ausführt. Wenn dies Ihr Haupt-UI-Thread ist, wird dieser Thread in der AIDL-Schnittstelle weiter ausgeführt. Wenn es sich um einen anderen Thread handelt, ist dies der Thread, der Ihren Code im Dienst ausführt. Wenn also nur lokale Threads auf den Dienst zugreifen, können Sie vollständig steuern, welche Threads darin ausgeführt werden. Wenn das der Fall ist, solltest du AIDL überhaupt nicht verwenden, sondern die Schnittstelle durch Implementieren eines Binder erstellen.
  • Aufrufe von einem Remoteprozess werden von einem Threadpool gesendet, den die Plattform in Ihrem eigenen Prozess verwaltet. Seien Sie auf eingehende Anrufe von unbekannten Threads vorbereitet, wobei mehrere Anrufe gleichzeitig eingehen können. Mit anderen Worten: Eine Implementierung einer AIDL-Schnittstelle muss vollständig threadsicher sein. Aufrufe, die von einem Thread für dasselbe Remote-Objekt ausgeführt werden, kommen auf der Empfängerseite in der richtigen Reihenfolge an.
  • Das Schlüsselwort oneway ändert das Verhalten von Remote-Aufrufen. Wenn sie verwendet wird, wird ein Remote-Aufruf nicht blockiert. Die Transaktionsdaten werden gesendet und sofort zurückgegeben. Die Implementierung der Schnittstelle empfängt dies schließlich als regulären Aufruf aus dem Binder-Threadpool als normalen Remote-Aufruf. Wenn oneway mit einem lokalen Aufruf verwendet wird, hat dies keine Auswirkungen und der Aufruf ist weiterhin synchron.

AIDL-Schnittstelle definieren

Definieren Sie Ihre AIDL-Schnittstelle in einer .aidl-Datei mit der Syntax der Programmiersprache Java und speichern Sie sie dann im Quellcode im Verzeichnis src/ der Anwendung, die den Dienst hostet, und aller anderen Anwendungen, die an den Dienst gebunden sind.

Wenn Sie eine Anwendung erstellen, die die Datei .aidl enthält, generieren die Android SDK-Tools eine IBinder-Schnittstelle auf Grundlage der Datei .aidl und speichern sie im Verzeichnis gen/ des Projekts. Der Dienst muss die IBinder-Schnittstelle entsprechend implementieren. Die Clientanwendungen können dann an den Dienst gebunden werden und Methoden aus dem IBinder aufrufen, um IPC auszuführen.

So erstellen Sie einen gebundenen Dienst mit AIDL:

  1. Datei .aidl erstellen

    Diese Datei definiert die Programmierschnittstelle mit Methodensignaturen.

  2. Schnittstelle implementieren

    Die Android SDK-Tools generieren anhand Ihrer .aidl-Datei eine Schnittstelle in der Programmiersprache Java. Diese Schnittstelle hat eine innere abstrakte Klasse namens Stub, die Binder erweitert und Methoden aus Ihrer AIDL-Schnittstelle implementiert. Sie müssen die Klasse Stub erweitern und die Methoden implementieren.

  3. Schnittstelle für Clients freigeben

    Implementiere einen Service und überschreibe onBind(), um deine Implementierung der Klasse Stub zurückzugeben.

Achtung: Alle Änderungen, die Sie nach dem ersten Release an Ihrer AIDL-Schnittstelle vornehmen, müssen abwärtskompatibel sein, damit andere Anwendungen, die Ihren Dienst verwenden, nicht beeinträchtigt werden. Da Ihre .aidl-Datei in andere Anwendungen kopiert werden muss, damit diese auf die Schnittstelle Ihres Dienstes zugreifen können, müssen Sie die Unterstützung für die ursprüngliche Schnittstelle beibehalten.

AIDL-Datei erstellen

AIDL verwendet eine einfache Syntax, mit der Sie eine Schnittstelle mit einer oder mehreren Methoden deklarieren können, die Parameter annehmen und Werte zurückgeben können. Die Parameter und Rückgabewerte können von beliebigem Typ sein, auch andere AIDL-generierte Schnittstellen.

Sie müssen die Datei .aidl mit der Programmiersprache Java erstellen. In jeder .aidl-Datei muss eine einzelne Schnittstelle definiert werden. Es sind nur die Schnittstellendeklaration und die Methodensignaturen erforderlich.

Standardmäßig unterstützt AIDL die folgenden Datentypen:

  • Alle einfachen Typen mit Ausnahme von short in der Programmiersprache Java (z. B. int, long, char, boolean usw.)
  • Arrays beliebiger Typen, z. B. int[] oder MyParcelable[]
  • String
  • CharSequence
  • List

    Alle Elemente in List müssen einer der unterstützten Datentypen in dieser Liste oder eine der anderen von AIDL generierten Schnittstellen oder Parcelables sein, die Sie deklarieren. Ein List kann optional als parametrisierte Typklasse verwendet werden, z. B. List<String>. Die tatsächliche konkrete Klasse, die die andere Seite empfängt, ist immer ein ArrayList, obwohl die Methode für die Verwendung der List-Schnittstelle generiert wird.

  • Map

    Alle Elemente in Map müssen einer der unterstützten Datentypen in dieser Liste oder eine der anderen von AIDL generierten Schnittstellen oder Parcelables sein, die Sie deklarieren. Parametrisierte Typzuordnungen, z. B. in der Form Map<String,Integer>, werden nicht unterstützt. Die tatsächliche konkrete Klasse, die die andere Seite empfängt, ist immer ein HashMap, obwohl die Methode so generiert wird, dass sie die Schnittstelle Map verwendet. Erwägen Sie die Verwendung eines Bundle als Alternative zu Map.

Sie müssen für jeden zusätzlichen Typ, der nicht zuvor aufgeführt wurde, eine import-Anweisung einfügen, auch wenn er im selben Paket wie Ihre Schnittstelle definiert ist.

Beachten Sie beim Definieren Ihrer Dienstschnittstelle Folgendes:

  • Methoden können null oder mehr Parameter annehmen und einen Wert oder „void“ zurückgeben.
  • Für alle nicht primitiven Parameter ist ein Richtungstag erforderlich, das angibt, in welche Richtung die Daten fließen: in, out oder inout (siehe Beispiel unten).

    Primitive, String, IBinder und AIDL-generierte Schnittstellen sind standardmäßig in und können nicht anders sein.

    Achtung: Beschränken Sie die Richtung auf das, was wirklich erforderlich ist, da das Marshalling von Parametern aufwendig ist.

  • Alle Codekommentare in der Datei .aidl sind in der generierten IBinder-Schnittstelle enthalten, mit Ausnahme von Kommentaren vor den Import- und Paketanweisungen.
  • In der AIDL-Schnittstelle können String- und Int-Konstanten definiert werden, z. B. const int VERSION = 1;.
  • Methodenaufrufe werden von einem transact()-Code weitergeleitet, der normalerweise auf einem Methodenindex in der Schnittstelle basiert. Da dies die Versionsverwaltung erschwert, können Sie den Transaktionscode manuell einer Methode zuweisen: void method() = 10;.
  • Argumente und Rückgabetypen, die null sein können, müssen mit @nullable annotiert werden.

Hier sehen Sie eine .aidl-Beispieldatei:

// 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);
}

Speichern Sie die Datei .aidl im Verzeichnis src/ Ihres Projekts. Wenn Sie Ihre Anwendung erstellen, generieren die SDK-Tools die Schnittstellendatei IBinder im Verzeichnis gen/ Ihres Projekts. Der Name der generierten Datei entspricht dem Namen der .aidl-Datei, hat aber die Erweiterung .java. Beispiel: IRemoteService.aidl ergibt IRemoteService.java.

Wenn Sie Android Studio verwenden, wird die Binder-Klasse durch den inkrementellen Build fast sofort generiert. Wenn Sie Android Studio nicht verwenden, generiert das Gradle-Tool die Binder-Klasse, wenn Sie Ihre Anwendung das nächste Mal erstellen. Erstellen Sie Ihr Projekt mit gradle assembleDebug oder gradle assembleRelease, sobald Sie die .aidl-Datei geschrieben haben, damit Ihr Code mit der generierten Klasse verknüpft werden kann.

Schnittstelle implementieren

Wenn Sie Ihre Anwendung erstellen, generieren die Android SDK-Tools eine .java-Schnittstellendatei, die nach Ihrer .aidl-Datei benannt ist. Die generierte Schnittstelle enthält eine abgeleitete Klasse namens Stub, die eine abstrakte Implementierung der übergeordneten Schnittstelle ist, z. B. YourInterface.Stub, und alle Methoden aus der .aidl-Datei deklariert.

Hinweis: Stub definiert auch einige Hilfsmethoden, insbesondere asInterface(), die ein IBinder-Objekt akzeptiert, das normalerweise an die Callback-Methode onServiceConnected() eines Clients übergeben wird, und eine Instanz der Stub-Schnittstelle zurückgibt. Weitere Informationen zu dieser Umwandlung finden Sie im Abschnitt IPC-Methode aufrufen.

Wenn Sie die aus der .aidl-Datei generierte Schnittstelle implementieren möchten, erweitern Sie die generierte Binder-Schnittstelle, z. B. YourInterface.Stub, und implementieren Sie die von der .aidl-Datei übernommenen Methoden.

Hier ist ein Beispiel für die Implementierung einer Schnittstelle namens IRemoteService, die im vorherigen IRemoteService.aidl-Beispiel definiert wurde, mit einer anonymen Instanz:

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.
    }
}

Jetzt ist binder eine Instanz der Klasse Stub (ein Binder), die die IPC-Schnittstelle für den Dienst definiert. Im nächsten Schritt wird diese Instanz für Clients freigegeben, damit sie mit dem Dienst interagieren können.

Beachten Sie bei der Implementierung Ihrer AIDL-Schnittstelle die folgenden Regeln:

  • Es ist nicht garantiert, dass eingehende Anrufe im Hauptthread ausgeführt werden. Daher müssen Sie von Anfang an Multithreading berücksichtigen und Ihren Dienst so erstellen, dass er threadsicher ist.
  • Standardmäßig sind IPC-Aufrufe synchron. Wenn Sie wissen, dass der Dienst mehr als ein paar Millisekunden benötigt, um eine Anfrage abzuschließen, rufen Sie ihn nicht über den Hauptthread der Aktivität auf. Dies kann dazu führen, dass die Anwendung hängen bleibt und Android das Dialogfeld „App reagiert nicht“ anzeigt. Rufen Sie sie über einen separaten Thread im Client auf.
  • Nur die Ausnahmetypen, die in der Referenzdokumentation für Parcel.writeException() aufgeführt sind, werden an den Aufrufer zurückgesendet.

Schnittstelle für Clients freigeben

Nachdem Sie die Schnittstelle für Ihren Dienst implementiert haben, müssen Sie sie für Clients verfügbar machen, damit sie daran gebunden werden können. Wenn Sie die Schnittstelle für Ihren Dienst verfügbar machen möchten, erweitern Sie Service und implementieren Sie onBind(), um eine Instanz Ihrer Klasse zurückzugeben, die die generierte Stub implementiert, wie im vorherigen Abschnitt beschrieben. Hier ist ein Beispieldienst, der die Beispielschnittstelle IRemoteService für Clients verfügbar macht.

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.
        }
    }
}

Wenn ein Client, z. B. eine Aktivität, bindService() aufruft, um eine Verbindung zu diesem Dienst herzustellen, empfängt der onServiceConnected()-Callback des Clients die binder-Instanz, die von der onBind()-Methode des Dienstes zurückgegeben wird.

Der Client muss auch Zugriff auf die Schnittstellenklasse haben. Wenn sich der Client und der Dienst in separaten Anwendungen befinden, muss die Anwendung des Clients eine Kopie der .aidl-Datei im Verzeichnis src/ haben. Dadurch wird die android.os.Binder-Schnittstelle generiert, die dem Client Zugriff auf die AIDL-Methoden gewährt.

Wenn der Client den IBinder im onServiceConnected()-Callback empfängt, muss er YourServiceInterface.Stub.asInterface(service) aufrufen, um den zurückgegebenen Parameter in den Typ YourServiceInterface umzuwandeln:

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
    }
}

Weitere Codebeispiele findest du in der Klasse RemoteService.java in ApiDemos.

Objekte über IPC übergeben

In Android 10 (API-Level 29 oder höher) können Sie Parcelable-Objekte direkt in AIDL definieren. Typen, die als AIDL-Schnittstellenargumente und andere Parcelables unterstützt werden, werden hier ebenfalls unterstützt. So sparen Sie sich die zusätzliche Arbeit, Marshalling-Code und eine benutzerdefinierte Klasse manuell zu schreiben. Dadurch wird jedoch auch eine leere Struktur erstellt. Wenn benutzerdefinierte Zugriffsfunktionen oder andere Funktionen gewünscht sind, implementieren Sie stattdessen 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;
}

Im vorherigen Codebeispiel wird automatisch eine Java-Klasse mit den Ganzzahlfeldern left, top, right und bottom generiert. Der gesamte relevante Marshalling-Code wird automatisch implementiert und das Objekt kann direkt verwendet werden, ohne dass eine Implementierung hinzugefügt werden muss.

Sie können auch eine benutzerdefinierte Klasse über eine IPC-Schnittstelle von einem Prozess an einen anderen senden. Achten Sie jedoch darauf, dass der Code für Ihre Klasse auf der anderen Seite des IPC-Kanals verfügbar ist und Ihre Klasse die Schnittstelle Parcelable unterstützt. Die Unterstützung von Parcelable ist wichtig, da das Android-System damit Objekte in primitive Typen zerlegen kann, die prozessübergreifend gemarshallt werden können.

So erstellen Sie eine benutzerdefinierte Klasse, die Parcelable unterstützt:

  1. Lassen Sie Ihre Klasse die Parcelable-Schnittstelle implementieren.
  2. Implementieren Sie writeToParcel, um den aktuellen Status des Objekts zu erfassen und in ein Parcel zu schreiben.
  3. Fügen Sie Ihrer Klasse ein statisches Feld mit dem Namen CREATOR hinzu, das ein Objekt ist, das die Schnittstelle Parcelable.Creator implementiert.
  4. Erstellen Sie abschließend eine .aidl-Datei, in der Sie Ihre parcelable-Klasse deklarieren, wie in der folgenden Rect.aidl-Datei gezeigt.

    Wenn Sie einen benutzerdefinierten Build-Prozess verwenden, fügen Sie die Datei .aidl nicht zu Ihrem Build hinzu. Ähnlich wie eine Header-Datei in der Programmiersprache C wird diese .aidl-Datei nicht kompiliert.

AIDL verwendet diese Methoden und Felder im generierten Code, um Ihre Objekte zu marshallen und zu unmarshallen.

Hier ist beispielsweise eine Rect.aidl-Datei zum Erstellen einer Rect-Klasse, die parcelable ist:

package android.graphics;

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

Hier ist ein Beispiel dafür, wie die Klasse Rect das Protokoll Parcelable implementiert.

// 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
    }
}

Das Marshalling in der Klasse Rect ist unkompliziert. Sehen Sie sich die anderen Methoden für Parcel an, um zu erfahren, welche anderen Arten von Werten Sie in ein Parcel schreiben können.

Warnung: Denken Sie an die Sicherheitsauswirkungen, wenn Sie Daten von anderen Prozessen empfangen. In diesem Fall liest die Rect vier Zahlen aus der Parcel. Sie müssen jedoch dafür sorgen, dass diese innerhalb des zulässigen Wertebereichs für die Aktion des Aufrufers liegen. Weitere Informationen zum Schutz Ihrer Anwendung vor Malware finden Sie unter Sicherheitstipps.

Methoden mit Bundle-Argumenten, die Parcelables enthalten

Wenn eine Methode ein Bundle-Objekt akzeptiert, das voraussichtlich Parcelables enthält, müssen Sie den Classloader des Bundle-Objekts durch Aufrufen von Bundle.setClassLoader(ClassLoader) festlegen, bevor Sie versuchen, aus dem Bundle-Objekt zu lesen. Andernfalls tritt ein ClassNotFoundException auf, obwohl das Parcelable in Ihrer Anwendung korrekt definiert ist.

Nehmen wir als Beispiel die folgende Datei .aidl:

// 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);
}
Wie in der folgenden Implementierung gezeigt, wird die ClassLoader explizit in der Bundle festgelegt, bevor Rect gelesen wird:
private val binder = object : IRectInsideBundle.Stub() {
    override fun saveRect(bundle: Bundle) {
        bundle.classLoader = classLoader
        val rect = BundleCompat.getParcelable(bundle, "rect", Rect::class.java)
        process(rect) // Do more with the parcelable.
    }
}

IPC-Methode aufrufen

So rufen Sie eine mit AIDL definierte Remote-Schnittstelle in Ihrer aufrufenden Klasse auf:

  1. Fügen Sie die Datei .aidl in das Projektverzeichnis src/ ein.
  2. Deklariere eine Instanz der IBinder-Schnittstelle, die auf Grundlage der AIDL generiert wird.
  3. ServiceConnection implementieren.
  4. Rufen Sie Context.bindService() auf und übergeben Sie Ihre ServiceConnection-Implementierung.
  5. In Ihrer Implementierung von onServiceConnected() erhalten Sie eine IBinder-Instanz namens service. Rufen Sie YourInterfaceName.Stub.asInterface((IBinder)service) auf, um den zurückgegebenen Parameter in den Typ YourInterface umzuwandeln.
  6. Rufen Sie die Methoden auf, die Sie in Ihrer Schnittstelle definiert haben. Fangen Sie immer DeadObjectException-Ausnahmen ab, die ausgelöst werden, wenn die Verbindung unterbrochen wird. Fange außerdem SecurityException-Ausnahmen ab, die ausgelöst werden, wenn die beiden am IPC-Methodenaufruf beteiligten Prozesse widersprüchliche AIDL-Definitionen haben.
  7. Wenn du die Verbindung trennen möchtest, rufe Context.unbindService() mit der Instanz deiner Schnittstelle auf.

Beachten Sie beim Aufrufen eines IPC-Dienstes Folgendes:

  • Objekte werden prozessübergreifend referenziert.
  • Sie können anonyme Objekte als Methodenargumente senden.

Weitere Informationen zum Binden an einen Dienst finden Sie in der Übersicht über gebundene Dienste.

Hier ist ein Beispielcode, der den Aufruf eines mit AIDL erstellten Dienstes zeigt. Er stammt aus dem Beispiel für einen Remote-Dienst im ApiDemos-Projekt.

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)
            }
        }
    }
}