Język definiowania interfejsu Androida (AIDL) jest podobny do innych języków IDL: umożliwia zdefiniowanie interfejsu programowania, który jest akceptowany zarówno przez klienta, jak i usługę, aby mogły się ze sobą komunikować za pomocą komunikacji między procesami (IPC).
Na Androidzie jeden proces zwykle nie ma dostępu do pamięci innego procesu. Aby się komunikować, muszą rozłożyć swoje obiekty na elementy podstawowe, które system operacyjny może zrozumieć, i uporządkować je dla Ciebie. Kod do tego przekształcania jest żmudny do napisania, więc Android obsługuje go za pomocą AIDL.
Uwaga: AIDL jest konieczny tylko wtedy, gdy zezwalasz klientom z różnych aplikacji na dostęp do usługi na potrzeby IPC i chcesz obsługiwać wielowątkowość w usłudze. Jeśli nie musisz wykonywać równoczesnych wywołań IPC w różnych aplikacjach, utwórz interfejs, implementując Binder.
Jeśli chcesz przeprowadzić IPC, ale nie musisz obsługiwać wielowątkowości, zaimplementuj interfejs za pomocą Messenger.
Niezależnie od tego, zanim wdrożysz AIDL, zapoznaj się z powiązanymi usługami.
Zanim zaczniesz projektować interfejs AIDL, pamiętaj, że wywołania interfejsu AIDL są bezpośrednimi wywołaniami funkcji. Nie zakładaj, że wywołanie następuje w konkretnym wątku. To, co się stanie, zależy od tego, czy wywołanie pochodzi z wątku w procesie lokalnym czy zdalnym:
- Wywołania z procesu lokalnego są wykonywane w tym samym wątku, który je wywołuje. Jeśli jest to główny wątek UI, będzie on nadal wykonywany w interfejsie AIDL. Jeśli jest to inny wątek, to właśnie on wykonuje Twój kod w usłudze. Jeśli więc tylko wątki lokalne mają dostęp do usługi, możesz całkowicie kontrolować, które wątki są w niej wykonywane. Jeśli tak jest, nie używaj AIDL, tylko utwórz interfejs, implementując
Binder. - Wywołania z procesu zdalnego są wysyłane z puli wątków, którą platforma utrzymuje w Twoim procesie. Przygotuj się na połączenia przychodzące z nieznanych wątków, z wieloma połączeniami jednocześnie. Innymi słowy, implementacja interfejsu AIDL musi być całkowicie wątkowo bezpieczna. Wywołania z jednego wątku na tym samym obiekcie zdalnym docierają do odbiorcy w kolejności.
- Słowo kluczowe
onewaymodyfikuje działanie wywołań zdalnych. Gdy jest używana, zdalne połączenie nie jest blokowane. Wysyła dane transakcji i natychmiast zwraca wynik. Implementacja interfejsu ostatecznie otrzymuje to jako zwykłe wywołanie z puli wątkówBinderjako normalne wywołanie zdalne. Jeślionewayjest używany z wywołaniem lokalnym, nie ma to wpływu na działanie, a wywołanie jest nadal synchroniczne.
Definiowanie interfejsu AIDL
Zdefiniuj interfejs AIDL w pliku .aidl, używając składni języka programowania Java, a następnie zapisz go w kodzie źródłowym w katalogu src/ zarówno aplikacji hostującej usługę, jak i każdej innej aplikacji, która się z nią wiąże.
Gdy tworzysz aplikację zawierającą plik .aidl, narzędzia Android SDK generują interfejs IBinder na podstawie pliku .aidl i zapisują go w katalogu gen/ projektu. Usługa musi odpowiednio implementować interfejs IBinder. Aplikacje klienckie mogą następnie powiązać się z usługą i wywoływać metody z IBinder, aby wykonywać IPC.
Aby utworzyć powiązaną usługę za pomocą AIDL, wykonaj czynności opisane w tych sekcjach:
- Tworzenie pliku
.aidlTen plik definiuje interfejs programowania z sygnaturami metod.
- Implementowanie interfejsu
Narzędzia Android SDK generują interfejs w języku programowania Java na podstawie pliku
.aidl. Ten interfejs ma wewnętrzną klasę abstrakcyjną o nazwieStub, która rozszerza klasęBinderi implementuje metody z interfejsu AIDL. Musisz rozszerzyć klasęStubi wdrożyć metody. - Udostępnianie interfejsu klientom
Zaimplementuj
Servicei zastąponBind(), aby zwrócić implementację klasyStub.
Uwaga: wszelkie zmiany wprowadzone w interfejsie AIDL po pierwszej wersji muszą być zgodne wstecznie, aby nie zakłócać działania innych aplikacji korzystających z Twojej usługi. Oznacza to, że ponieważ plik .aidl musi zostać skopiowany do innych aplikacji, aby mogły one uzyskać dostęp do interfejsu usługi, musisz zachować obsługę oryginalnego interfejsu.
Tworzenie pliku .aidl
AIDL używa prostej składni, która umożliwia zadeklarowanie interfejsu z co najmniej 1 metodą, która może przyjmować parametry i zwracać wartości. Parametry i zwracane wartości mogą być dowolnego typu, nawet innych interfejsów wygenerowanych przez AIDL.
Plik .aidl musisz utworzyć w języku programowania Java. Każdy plik .aidl musi definiować pojedynczy interfejs i wymaga tylko deklaracji interfejsu oraz sygnatur metod.
Domyślnie AIDL obsługuje te typy danych:
- Wszystkie typy podstawowe w języku programowania Java (takie jak
int,long,char,booleanitd.) z wyjątkiemshort. - tablice dowolnego typu, np.
int[]lubMyParcelable[]; StringCharSequenceListWszystkie elementy w
Listmuszą być jednym z obsługiwanych typów danych na tej liście lub jednym z innych zadeklarowanych przez Ciebie interfejsów wygenerowanych przez AIDL lub obiektów Parcelable.Listmożna opcjonalnie użyć jako klasy typu sparametryzowanego, np.List<String>. Rzeczywista klasa konkretna, którą otrzymuje druga strona, to zawszeArrayList, chociaż metoda jest generowana do używania interfejsuList.MapWszystkie elementy w
Mapmuszą być jednym z obsługiwanych typów danych na tej liście lub jednym z innych zadeklarowanych przez Ciebie interfejsów wygenerowanych przez AIDL lub obiektów Parcelable. Mapy typów sparametryzowanych, takie jak te w formieMap<String,Integer>, nie są obsługiwane. Rzeczywista klasa konkretna, którą otrzymuje druga strona, to zawszeHashMap, chociaż metoda jest generowana do używania interfejsuMap. ZamiastMaprozważ użycieBundle.
Musisz dołączyć instrukcję import dla każdego dodatkowego typu, który nie został wcześniej wymieniony, nawet jeśli jest on zdefiniowany w tym samym pakiecie co interfejs.
Podczas definiowania interfejsu usługi pamiętaj, że:
- Metody mogą przyjmować zero lub więcej parametrów i mogą zwracać wartość lub void.
- Wszystkie parametry inne niż podstawowe wymagają tagu kierunkowego wskazującego, w którą stronę przesyłane są dane:
in,outlubinout(patrz przykład poniżej).Typy podstawowe,
String,IBinderi interfejsy wygenerowane przez AIDL są domyślnieini nie mogą być inne.Uwaga: ogranicz kierunek do tego, co jest naprawdę potrzebne, ponieważ przekazywanie parametrów jest kosztowne.
- Wszystkie komentarze do kodu zawarte w pliku
.aidlsą uwzględniane w wygenerowanym interfejsieIBinder, z wyjątkiem komentarzy przed instrukcjami importu i pakietu. - W interfejsie AIDL można definiować stałe typu String i Int, np.
const int VERSION = 1;. - Wywołania metod są wysyłane przez kod
transact(), który zwykle opiera się na indeksie metody w interfejsie. Utrudnia to obsługę wersji, dlatego możesz ręcznie przypisać kod transakcji do metody:void method() = 10;. - Argumenty i zwracane typy, które mogą mieć wartość null, muszą być oznaczone adnotacją
@nullable.
Oto przykładowy plik .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); }
Zapisz plik .aidl w katalogu src/ projektu. Gdy tworzysz aplikację, narzędzia SDK generują plik interfejsu IBinder w katalogu gen/ projektu. Nazwa wygenerowanego pliku jest taka sama jak nazwa pliku .aidl, ale ma rozszerzenie .java. Na przykład IRemoteService.aidl daje IRemoteService.java.
Jeśli używasz Android Studio, kompilacja przyrostowa generuje klasę binder niemal natychmiast.
Jeśli nie używasz Android Studio, narzędzie Gradle wygeneruje klasę binder przy następnym tworzeniu aplikacji. Skompiluj projekt za pomocą gradle assembleDebug lub gradle assembleRelease, gdy tylko skończysz pisać plik .aidl, aby kod mógł zostać połączony z wygenerowaną klasą.
Implementowanie interfejsu
Gdy tworzysz aplikację, narzędzia Android SDK generują plik interfejsu .java o nazwie odpowiadającej plikowi .aidl. Wygenerowany interfejs zawiera podklasę o nazwie Stub, która jest abstrakcyjną implementacją interfejsu nadrzędnego, np. YourInterface.Stub, i deklaruje wszystkie metody z pliku .aidl.
Uwaga: Stub definiuje też kilka metod pomocniczych, z których najważniejsza to asInterface(). Przyjmuje ona IBinder, zwykle przekazywany do metody wywołania zwrotnego onServiceConnected() klienta, i zwraca instancję interfejsu stub. Więcej informacji o tym, jak wykonać to rzutowanie, znajdziesz w sekcji Wywoływanie metody IPC.
Aby zaimplementować interfejs wygenerowany z pliku .aidl, rozszerz wygenerowany interfejs Binder, np. YourInterface.Stub, i zaimplementuj metody odziedziczone z pliku .aidl.
Oto przykładowa implementacja interfejsu o nazwie IRemoteService, zdefiniowanego w poprzednim przykładzie IRemoteService.aidl, z użyciem instancji anonimowej:
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. } }
Teraz binder jest instancją klasy Stub (Binder), która definiuje interfejs IPC usługi. W następnym kroku ta instancja zostanie udostępniona klientom, aby mogli korzystać z usługi.
Podczas implementowania interfejsu AIDL pamiętaj o kilku regułach:
- Nie ma gwarancji, że połączenia przychodzące będą wykonywane w głównym wątku, dlatego od samego początku musisz pomyśleć o wielowątkowości i odpowiednio utworzyć usługę, aby była wątkowo bezpieczna.
- Domyślnie wywołania IPC są synchroniczne. Jeśli wiesz, że usługa potrzebuje więcej niż kilka milisekund na zrealizowanie żądania, nie wywołuj jej z głównego wątku aktywności. Może to spowodować zawieszenie aplikacji i wyświetlenie przez Androida okna „Aplikacja nie odpowiada”. wywołać go z osobnego wątku w kliencie.
- Do elementu wywołującego są odsyłane tylko typy wyjątków wymienione w dokumentacji referencyjnej
Parcel.writeException().
Udostępnianie interfejsu klientom
Po zaimplementowaniu interfejsu usługi musisz udostępnić go klientom, aby mogli się z nim powiązać. Aby udostępnić interfejs usługi, rozszerz Service i zaimplementuj onBind(), aby zwrócić instancję klasy, która implementuje wygenerowany Stub, jak opisano w poprzedniej sekcji. Oto przykładowa usługa, która udostępnia klientom przykładowy interfejs IRemoteService.
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. } } }
Teraz, gdy klient, np. aktywność, wywołuje bindService(), aby połączyć się z tą usługą, wywołanie zwrotne onServiceConnected() klienta otrzymuje instancję binder zwracaną przez metodę onBind() usługi.
Klient musi też mieć dostęp do klasy interfejsu. Jeśli więc klient i usługa znajdują się w osobnych aplikacjach, aplikacja klienta musi mieć kopię pliku .aidl w katalogu src/, który generuje interfejs android.os.Binder, zapewniając klientowi dostęp do metod AIDL.
Gdy klient otrzyma IBinder w wywołaniu zwrotnym onServiceConnected(), musi wywołać YourServiceInterface.Stub.asInterface(service), aby rzutować zwrócony parametr na typ YourServiceInterface:
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 } }
Więcej przykładowego kodu znajdziesz w klasie RemoteService.java w ApiDemos.
Przekazywanie obiektów przez IPC
W Androidzie 10 (poziom interfejsu API 29 lub wyższy) możesz definiować obiekty Parcelable bezpośrednio w AIDL. Obsługiwane są też typy, które są obsługiwane jako argumenty interfejsu AIDL i inne obiekty parcelable. Dzięki temu unikniesz dodatkowej pracy związanej z ręcznym pisaniem kodu przekształcania i niestandardowej klasy. Jednak powoduje to też utworzenie pustej struktury. Jeśli potrzebujesz niestandardowych akcesorów lub innych funkcji, zaimplementuj 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;
}
Powyższy przykładowy kod automatycznie generuje klasę Java z polami liczb całkowitych left, top, right i bottom. Cały odpowiedni kod przekształcania jest implementowany automatycznie, a obiektu można używać bezpośrednio bez konieczności dodawania jakiejkolwiek implementacji.
Możesz też wysłać klasę niestandardową z jednego procesu do drugiego za pomocą interfejsu IPC. Upewnij się jednak, że kod klasy jest dostępny po drugiej stronie kanału IPC i że klasa obsługuje interfejs Parcelable. Obsługa interfejsu Parcelable jest ważna, ponieważ umożliwia systemowi Android rozkładanie obiektów na elementy podstawowe, które można przekazywać między procesami.
Aby utworzyć klasę niestandardową, która obsługuje Parcelable, wykonaj te czynności:
- Zaimplementuj w klasie interfejs
Parcelable. - Zaimplementuj metodę
writeToParcel, która pobiera bieżący stan obiektu i zapisuje go w obiekcieParcel. - Dodaj do klasy pole statyczne o nazwie
CREATOR, które jest obiektem implementującym interfejsParcelable.Creator. - Na koniec utwórz plik
.aidl, który deklaruje klasę parcelable, jak pokazano w plikuRect.aidlponiżej.Jeśli używasz niestandardowego procesu kompilacji, nie dodawaj do kompilacji pliku
.aidl. Podobnie jak plik nagłówka w języku C, ten plik.aidlnie jest kompilowany.
AIDL używa tych metod i pól w generowanym kodzie do przekształcania i odtworzenia obiektów.
Oto przykład pliku Rect.aidl, który tworzy klasę Rect możliwą do spakowania:
package android.graphics; // Declare Rect so AIDL can find it and knows that it implements // the parcelable protocol. parcelable Rect;
Oto przykład implementacji protokołu Parcelable przez klasę Rect.
// 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 } }
Przekształcanie w klasie Rect jest proste. Zapoznaj się z innymi metodami w Parcel, aby zobaczyć, jakie inne rodzaje wartości możesz zapisać w Parcel.
Ostrzeżenie: pamiętaj o konsekwencjach dla bezpieczeństwa, jakie wiążą się z otrzymywaniem danych z innych procesów. W tym przypadku Rect odczytuje 4 cyfry z Parcel, ale to Ty musisz zadzwonić, aby upewnić się, że mieszczą się one w akceptowalnym zakresie wartości dla tego, co próbuje zrobić rozmówca. Więcej informacji o tym, jak chronić aplikację przed złośliwym oprogramowaniem, znajdziesz w artykule ze wskazówkami dotyczącymi bezpieczeństwa.
Metody z argumentami Bundle zawierającymi obiekty Parcelable
Jeśli metoda akceptuje obiektBundle, który powinien zawierać
obiekty parcelable, przed próbą odczytu
z obiektu Bundle ustaw jego classloaderBundle,
wywołując Bundle.setClassLoader(ClassLoader). W przeciwnym razie wystąpi błąd ClassNotFoundException, mimo że obiekt Parcelable jest prawidłowo zdefiniowany w aplikacji.
Rozważmy na przykład ten przykładowy plik .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 jest jawnie ustawiany w Bundle przed odczytem Rect:
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. } }
Wywoływanie metody IPC
Aby wywołać interfejs zdalny zdefiniowany za pomocą AIDL, wykonaj te czynności w klasie wywołującej:
- Uwzględnij plik
.aidlw katalogu projektusrc/. - Zadeklaruj instancję interfejsu
IBinder, który jest generowany na podstawie AIDL. - Wdrożenie:
ServiceConnection. - Wywołaj funkcję
Context.bindService(), przekazując implementacjęServiceConnection. - W implementacji
onServiceConnected()otrzymujesz instancjęIBindero nazwieservice. Wywołaj funkcjęYourInterfaceName.Stub.asInterface((IBinder)service), aby rzutować zwrócony parametr na typYourInterface. - Wywołaj metody zdefiniowane w interfejsie. Zawsze przechwytuj wyjątki
DeadObjectException, które są zgłaszane, gdy połączenie zostanie przerwane. Przechwytuj też wyjątkiSecurityException, które są zgłaszane, gdy 2 procesy zaangażowane w wywołanie metody IPC mają sprzeczne definicje AIDL. - Aby się rozłączyć, wywołaj
Context.unbindService()z instancją interfejsu.
Podczas wywoływania usługi IPC pamiętaj o tych kwestiach:
- Obiekty są zliczane przez odwołania w procesach.
- Możesz wysyłać obiekty anonimowe jako argumenty metody.
Więcej informacji o powiązaniu z usługą znajdziesz w artykule Omówienie powiązanych usług.
Oto przykładowy kod, który pokazuje wywołanie usługi utworzonej za pomocą AIDL. Pochodzi on z przykładu usługi zdalnej w projekcie ApiDemos.
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) } } } }