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
Bindererstellen. - 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 demBinder-Threadpool als normalen Remote-Aufruf. Wennonewaymit 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:
- Datei
.aidlerstellenDiese Datei definiert die Programmierschnittstelle mit Methodensignaturen.
- Schnittstelle implementieren
Die Android SDK-Tools generieren anhand Ihrer
.aidl-Datei eine Schnittstelle in der Programmiersprache Java. Diese Schnittstelle hat eine innere abstrakte Klasse namensStub, dieBindererweitert und Methoden aus Ihrer AIDL-Schnittstelle implementiert. Sie müssen die KlasseStuberweitern und die Methoden implementieren. - Schnittstelle für Clients freigeben
Implementiere einen
Serviceund überschreibeonBind(), um deine Implementierung der KlasseStubzurü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
shortin der Programmiersprache Java (z. B.int,long,char,booleanusw.) - Arrays beliebiger Typen, z. B.
int[]oderMyParcelable[] StringCharSequenceListAlle Elemente in
Listmüssen einer der unterstützten Datentypen in dieser Liste oder eine der anderen von AIDL generierten Schnittstellen oder Parcelables sein, die Sie deklarieren. EinListkann optional als parametrisierte Typklasse verwendet werden, z. B.List<String>. Die tatsächliche konkrete Klasse, die die andere Seite empfängt, ist immer einArrayList, obwohl die Methode für die Verwendung derList-Schnittstelle generiert wird.MapAlle Elemente in
Mapmü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 FormMap<String,Integer>, werden nicht unterstützt. Die tatsächliche konkrete Klasse, die die andere Seite empfängt, ist immer einHashMap, obwohl die Methode so generiert wird, dass sie die SchnittstelleMapverwendet. Erwägen Sie die Verwendung einesBundleals Alternative zuMap.
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,outoderinout(siehe Beispiel unten).Primitive,
String,IBinderund AIDL-generierte Schnittstellen sind standardmäßiginund 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
.aidlsind in der generiertenIBinder-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
@nullableannotiert 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:
- Lassen Sie Ihre Klasse die
Parcelable-Schnittstelle implementieren. - Implementieren Sie
writeToParcel, um den aktuellen Status des Objekts zu erfassen und in einParcelzu schreiben. - Fügen Sie Ihrer Klasse ein statisches Feld mit dem Namen
CREATORhinzu, das ein Objekt ist, das die SchnittstelleParcelable.Creatorimplementiert. - Erstellen Sie abschließend eine
.aidl-Datei, in der Sie Ihre parcelable-Klasse deklarieren, wie in der folgendenRect.aidl-Datei gezeigt.Wenn Sie einen benutzerdefinierten Build-Prozess verwenden, fügen Sie die Datei
.aidlnicht 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 einBundle-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); }
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:
- Fügen Sie die Datei
.aidlin das Projektverzeichnissrc/ein. - Deklariere eine Instanz der
IBinder-Schnittstelle, die auf Grundlage der AIDL generiert wird. ServiceConnectionimplementieren.- Rufen Sie
Context.bindService()auf und übergeben Sie IhreServiceConnection-Implementierung. - In Ihrer Implementierung von
onServiceConnected()erhalten Sie eineIBinder-Instanz namensservice. Rufen SieYourInterfaceName.Stub.asInterface((IBinder)service)auf, um den zurückgegebenen Parameter in den TypYourInterfaceumzuwandeln. - 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ßerdemSecurityException-Ausnahmen ab, die ausgelöst werden, wenn die beiden am IPC-Methodenaufruf beteiligten Prozesse widersprüchliche AIDL-Definitionen haben. - 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—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) } } } }