Android Interface Definition Language (AIDL) mirip dengan IDL lainnya: AIDL memungkinkan Anda menentukan antarmuka pemrograman yang disepakati oleh klien dan layanan untuk berkomunikasi satu sama lain menggunakan komunikasi antar-proses (IPC).
Di Android, satu proses biasanya tidak dapat mengakses memori proses lain. Untuk berkomunikasi, keduanya perlu menguraikan objeknya menjadi primitif yang dapat dipahami oleh sistem operasi dan menyusun objek tersebut melintasi batas tersebut untuk Anda. Kode untuk melakukan marshalling tersebut membosankan untuk ditulis, jadi Android menanganinya untuk Anda dengan AIDL.
Catatan: AIDL hanya diperlukan jika Anda mengizinkan klien dari
berbagai aplikasi mengakses layanan Anda untuk IPC dan Anda ingin menangani multithreading dalam
layanan Anda. Jika Anda tidak perlu melakukan IPC serentak di berbagai
aplikasi, buat antarmuka dengan mengimplementasikan
Binder.
Jika Anda ingin menjalankan IPC, tetapi tidak perlu menangani multithreading,
implementasikan antarmuka Anda menggunakan Messenger.
Terlepas dari itu, pastikan Anda memahami layanan terikat sebelum
mengimplementasikan AIDL.
Sebelum mulai mendesain antarmuka AIDL, ketahuilah bahwa panggilan ke antarmuka AIDL adalah panggilan fungsi langsung. Jangan membuat asumsi tentang thread tempat panggilan terjadi. Hal yang terjadi akan berbeda, bergantung pada apakah panggilan berasal dari thread dalam proses lokal atau proses jarak jauh:
- Panggilan yang dilakukan dari proses lokal dijalankan di thread yang sama dengan yang melakukan panggilan. Jika
ini adalah UI thread utama Anda, thread tersebut akan terus dieksekusi di antarmuka AIDL. Jika thread tersebut adalah thread lain, thread itulah yang mengeksekusi kode Anda di layanan. Dengan demikian, jika hanya thread lokal yang mengakses layanan, Anda dapat sepenuhnya mengontrol thread mana yang dieksekusi di dalamnya. Namun,
jika demikian, jangan gunakan AIDL sama sekali; sebagai gantinya, buat
antarmuka dengan mengimplementasikan
Binder. - Panggilan dari proses jarak jauh dikirim dari thread pool yang dikelola platform di dalam proses Anda sendiri. Bersiaplah untuk panggilan masuk dari thread yang tidak dikenal, dengan beberapa panggilan yang terjadi secara bersamaan. Dengan kata lain, implementasi antarmuka AIDL harus benar-benar aman untuk thread. Panggilan yang dilakukan dari satu thread pada objek jarak jauh yang sama akan tiba secara berurutan di sisi penerima.
- Kata kunci
onewaymengubah perilaku panggilan jarak jauh. Saat digunakan, panggilan jarak jauh tidak akan memblokir. Fungsi ini mengirimkan data transaksi dan segera menampilkan hasilnya. Implementasi antarmuka pada akhirnya akan menerima ini sebagai panggilan reguler dari thread poolBindersebagai panggilan jarak jauh normal. Jikaonewaydigunakan dengan panggilan lokal, tidak ada dampak, dan panggilan tetap sinkron.
Menentukan antarmuka AIDL
Tentukan antarmuka AIDL Anda dalam file .aidl menggunakan sintaksis bahasa
pemrograman Java, lalu simpan dalam kode sumber, di direktori src/, baik
aplikasi yang menghosting layanan maupun aplikasi lain yang terikat ke layanan.
Saat Anda mem-build setiap aplikasi yang berisi file .aidl, alat Android SDK
akan membuat antarmuka IBinder berdasarkan file .aidl dan menyimpannya di
direktori gen/ project. Layanan harus mengimplementasikan antarmuka IBinder
sebagaimana mestinya. Selanjutnya, aplikasi klien dapat mengikat ke layanan dan memanggil metode dari
IBinder untuk menjalankan IPC.
Untuk membuat layanan terikat menggunakan AIDL, ikuti langkah-langkah berikut, yang dijelaskan di bagian berikut:
- Membuat file
.aidlFile ini menentukan antarmuka pemrograman dengan tanda tangan metode.
- Mengimplementasikan antarmuka
Alat Android SDK menghasilkan antarmuka dalam bahasa pemrograman Java berdasarkan file
.aidlAnda. Antarmuka ini memiliki class abstrak dalam bernamaStubyang memperluasBinderdan mengimplementasikan metode dari antarmuka AIDL Anda. Anda harus memperluas classStubdan mengimplementasikan metodenya. - Mengekspos antarmuka ke klien
Terapkan
Servicedan gantionBind()untuk menampilkan penerapan classStub.
Perhatian: Setiap perubahan yang Anda buat pada antarmuka AIDL setelah
rilis pertama harus tetap kompatibel dengan versi lama agar tidak merusak aplikasi lain
yang menggunakan layanan Anda. Artinya, karena file .aidl harus disalin ke aplikasi lain
agar dapat mengakses antarmuka layanan, Anda harus mempertahankan dukungan untuk antarmuka
aslinya.
Membuat file .aidl
AIDL menggunakan sintaksis sederhana yang memungkinkan Anda mendeklarasikan antarmuka dengan satu atau beberapa metode yang dapat mengambil parameter dan menampilkan nilai. Parameter dan nilai yang ditampilkan dapat berupa jenis apa pun, bahkan antarmuka lain yang dihasilkan AIDL.
Anda harus membuat file .aidl menggunakan bahasa pemrograman Java. Setiap file .aidl
harus menentukan satu antarmuka dan hanya memerlukan deklarasi antarmuka dan tanda tangan
metode.
Secara default, AIDL mendukung jenis data berikut:
- Semua jenis primitif, kecuali
short, dalam bahasa pemrograman Java (sepertiint,long,char,boolean, dan sebagainya) - Array dari jenis apa pun, seperti
int[]atauMyParcelable[] StringCharSequenceListSemua elemen dalam
Listharus merupakan salah satu jenis data yang didukung dalam daftar ini atau salah satu antarmuka atau parcelable yang dihasilkan AIDL lainnya yang Anda deklarasikan.Listdapat digunakan secara opsional sebagai class jenis berparameter, sepertiList<String>. Class konkret sebenarnya yang diterima sisi lain selalu berupaArrayList, meskipun metode dibuat untuk menggunakan antarmukaList.MapSemua elemen dalam
Mapharus merupakan salah satu jenis data yang didukung dalam daftar ini atau salah satu antarmuka atau parcelable yang dihasilkan AIDL lainnya yang Anda deklarasikan. Peta jenis berparameter, seperti yang ada dalam bentukMap<String,Integer>, tidak didukung. Class konkret sebenarnya yang diterima pihak lain selalu berupaHashMap, meskipun metode ini dibuat untuk menggunakan antarmukaMap. Pertimbangkan untuk menggunakanBundlesebagai alternatif untukMap.
Anda harus menyertakan pernyataan import untuk setiap jenis tambahan yang tidak tercantum sebelumnya,
meskipun jenis tersebut ditentukan dalam paket yang sama dengan antarmuka Anda.
Saat menentukan antarmuka layanan, perhatikan bahwa:
- Metode dapat menggunakan nol atau beberapa parameter dan dapat menampilkan nilai atau void.
- Semua parameter non-primitif memerlukan tag arah yang menunjukkan arah data:
in,out, atauinout(lihat contoh di bawah).Primitif,
String,IBinder, dan antarmuka yang dihasilkan AIDL adalahinsecara default dan tidak dapat diubah.Perhatian: Batasi arah ke hal yang benar-benar diperlukan, karena parameter marshalling mahal.
- Semua komentar kode yang disertakan dalam file
.aidldisertakan dalam antarmukaIBinderyang dihasilkan, kecuali komentar sebelum pernyataan impor dan paket. - Konstanta string dan int dapat ditentukan di antarmuka AIDL, seperti
const int VERSION = 1;. - Panggilan metode dikirim oleh
kode
transact(), yang biasanya didasarkan pada indeks metode di antarmuka. Karena hal ini mempersulit pembuatan versi, Anda dapat menetapkan kode transaksi secara manual ke metode:void method() = 10;. - Argumen nullable dan jenis nilai yang ditampilkan harus dianotasi menggunakan
@nullable.
Berikut adalah contoh file .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); }
Simpan file .aidl di direktori src/ project Anda. Saat Anda
mem-build aplikasi, SDK Tools akan membuat file antarmuka IBinder di
direktori gen/ project Anda. Nama file yang dihasilkan cocok dengan nama file .aidl, tetapi
dengan ekstensi .java. Misalnya, IRemoteService.aidl menghasilkan IRemoteService.java.
Jika Anda menggunakan Android Studio, build inkremental akan menghasilkan class binder hampir seketika.
Jika Anda tidak menggunakan Android Studio, alat Gradle akan membuat class binder saat Anda
mem-build aplikasi berikutnya. Bangun project Anda dengan gradle assembleDebug
atau gradle assembleRelease segera setelah Anda selesai menulis file .aidl,
sehingga kode Anda dapat ditautkan ke class yang dihasilkan.
Mengimplementasikan antarmuka
Saat Anda mem-build aplikasi, Android SDK Tools akan membuat file antarmuka .java
yang diberi nama sesuai file .aidl Anda. Antarmuka yang dihasilkan menyertakan subclass bernama Stub
yang merupakan implementasi abstrak dari antarmuka induknya, seperti YourInterface.Stub, dan mendeklarasikan semua metode dari file .aidl.
Catatan: Stub juga
menentukan beberapa metode bantuan, terutama asInterface(), yang menggunakan IBinder, biasanya yang diteruskan ke metode callback onServiceConnected() klien, dan
menampilkan instance antarmuka stub. Untuk mengetahui detail selengkapnya tentang cara melakukan transmisi ini, lihat bagian Memanggil metode
IPC.
Untuk mengimplementasikan antarmuka yang dihasilkan dari .aidl, perluas antarmuka Binder
yang dihasilkan, seperti YourInterface.Stub, dan implementasikan metode
yang diwarisi dari file .aidl.
Berikut adalah contoh implementasi antarmuka bernama IRemoteService, yang ditentukan oleh contoh
IRemoteService.aidl sebelumnya, menggunakan instance anonim:
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. } }
Sekarang binder adalah instance class Stub (Binder),
yang menentukan antarmuka IPC untuk layanan. Pada langkah berikutnya, instance ini diekspos ke
klien sehingga mereka dapat berinteraksi dengan layanan.
Perhatikan beberapa aturan saat mengimplementasikan antarmuka AIDL:
- Panggilan masuk tidak dijamin akan dieksekusi di thread utama, jadi Anda perlu memikirkan multithreading sejak awal dan membangun layanan dengan benar agar aman untuk thread.
- Secara default, panggilan IPC bersifat sinkron. Jika Anda tahu bahwa layanan memerlukan waktu lebih dari beberapa milidetik untuk menyelesaikan permintaan, jangan panggil layanan tersebut dari thread utama aktivitas. Hal ini dapat membuat aplikasi hang, sehingga Android menampilkan dialog "Aplikasi Tidak Merespons". Panggil dari thread terpisah di klien.
- Hanya jenis pengecualian yang tercantum dalam dokumentasi referensi untuk
Parcel.writeException()yang dikirim kembali ke pemanggil.
Mengekspos antarmuka ke klien
Setelah mengimplementasikan antarmuka untuk layanan, Anda perlu mengeksposnya ke
klien agar mereka dapat mengikatnya. Untuk mengekspos antarmuka
layanan Anda, perluas Service dan implementasikan onBind() untuk menampilkan instance class Anda yang mengimplementasikan
Stub yang dihasilkan, seperti yang dibahas di bagian sebelumnya. Berikut adalah contoh
layanan yang mengekspos antarmuka contoh IRemoteService ke klien.
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. } } }
Sekarang, saat klien, seperti aktivitas, memanggil bindService() untuk terhubung ke layanan ini, callback onServiceConnected() klien akan menerima
instance binder yang ditampilkan oleh metode onBind()
layanan.
Klien juga harus memiliki akses ke class antarmuka. Jadi, jika klien dan layanan berada dalam
aplikasi yang terpisah, aplikasi klien harus memiliki salinan file .aidl
di direktori src/, yang menghasilkan antarmuka android.os.Binder,
sehingga memberikan akses klien ke metode AIDL.
Saat klien menerima IBinder
dalam callback onServiceConnected(), klien harus memanggil
YourServiceInterface.Stub.asInterface(service) untuk mentransmisikan parameter
yang ditampilkan ke jenis 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 } }
Untuk kode contoh lainnya, lihat
class
RemoteService.java di
ApiDemos.
Meneruskan objek melalui IPC
Di Android 10 (level API 29 atau yang lebih tinggi), Anda dapat menentukan
objek Parcelable langsung di
AIDL. Jenis yang didukung sebagai argumen antarmuka AIDL dan parcelable lainnya juga
didukung di sini. Hal ini menghindari pekerjaan tambahan untuk menulis kode marshalling dan class kustom secara manual. Namun, hal ini juga membuat struct kosong. Jika pengakses kustom atau fungsi lainnya
diinginkan, terapkan 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;
}
Contoh kode sebelumnya otomatis menghasilkan class Java dengan kolom bilangan bulat left,
top, right, dan bottom. Semua kode marshalling yang relevan
diimplementasikan secara otomatis, dan objek dapat digunakan secara langsung tanpa harus menambahkan
implementasi apa pun.
Anda juga dapat mengirim class kustom dari satu proses ke proses lain melalui antarmuka IPC. Namun,
pastikan kode untuk class Anda tersedia di sisi lain saluran IPC dan
class Anda harus mendukung antarmuka Parcelable. Mendukung
Parcelable itu penting
karena memungkinkan sistem Android menguraikan objek menjadi primitif yang dapat di-marshal
di seluruh proses.
Untuk membuat class kustom yang mendukung Parcelable, lakukan
hal berikut:
- Buat class Anda mengimplementasikan antarmuka
Parcelable. - Terapkan
writeToParcel, yang mengambil status objek saat ini dan menulisnya keParcel. - Tambahkan kolom statis bernama
CREATORke class Anda yang merupakan objek yang mengimplementasikan antarmukaParcelable.Creator. - Terakhir, buat file
.aidlyang mendeklarasikan class parcelable, seperti yang ditunjukkan untuk fileRect.aidlberikut.Jika Anda menggunakan proses build kustom, jangan tambahkan file
.aidlke build Anda. Mirip dengan file header dalam bahasa C, file.aidlini tidak dikompilasi.
AIDL menggunakan metode dan kolom ini dalam kode yang dihasilkannya untuk melakukan marshalling dan unmarshalling objek Anda.
Misalnya, berikut adalah file Rect.aidl untuk membuat class Rect yang
dapat dijadikan paket:
package android.graphics; // Declare Rect so AIDL can find it and knows that it implements // the parcelable protocol. parcelable Rect;
Berikut adalah contoh cara class Rect mengimplementasikan
protokol Parcelable.
// 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 } }
Penyusunan dalam class Rect sangat mudah. Lihat metode lain di Parcel untuk melihat jenis nilai lain yang dapat Anda tulis ke Parcel.
Peringatan: Ingat implikasi keamanan dari menerima
data dari proses lain. Dalam hal ini, Rect membaca empat angka dari Parcel, tetapi Anda harus memastikan bahwa angka tersebut berada dalam rentang nilai yang dapat diterima untuk apa pun yang coba dilakukan oleh pemanggil. Untuk mengetahui informasi selengkapnya tentang cara menjaga keamanan aplikasi Anda dari malware, lihat Tips keamanan.
Metode dengan argumen Bundle yang berisi Parcelable
Jika metode menerima objekBundle yang diharapkan berisi
parcelable, pastikan Anda menetapkan classloader Bundle dengan
memanggil Bundle.setClassLoader(ClassLoader) sebelum mencoba membaca
dari Bundle. Jika tidak, Anda akan mengalami ClassNotFoundException meskipun parcelable telah ditentukan dengan benar di aplikasi Anda.
Misalnya, perhatikan contoh file .aidl berikut:
// 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
ditetapkan secara eksplisit di Bundle sebelum membaca 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. } }
Memanggil metode IPC
Untuk memanggil antarmuka jarak jauh yang ditentukan dengan AIDL, lakukan langkah-langkah berikut di class panggilan Anda:
- Sertakan file
.aidldalam direktorisrc/project. - Deklarasikan instance antarmuka
IBinder, yang dibuat berdasarkan AIDL. - Menerapkan
ServiceConnection. - Panggil
Context.bindService(), dengan meneruskan implementasiServiceConnectionAnda. - Dalam penerapan
onServiceConnected(), Anda akan menerima instanceIBinder, yang disebutservice. PanggilYourInterfaceName.Stub.asInterface((IBinder)service)untuk mentransmisikan parameter yang ditampilkan ke jenisYourInterface. - Panggil metode yang Anda tentukan di antarmuka. Selalu tangkap pengecualian
DeadObjectException, yang ditampilkan saat koneksi terputus. Selain itu, trap pengecualianSecurityException, yang ditampilkan saat dua proses yang terlibat dalam panggilan metode IPC memiliki definisi AIDL yang bertentangan. - Untuk memutuskan koneksi, panggil
Context.unbindService()dengan instance antarmuka Anda.
Perhatikan poin-poin berikut saat memanggil layanan IPC:
- Objek adalah acuan yang dihitung lintas proses.
- Anda dapat mengirim objek anonim sebagai argumen metode.
Untuk mengetahui informasi selengkapnya tentang mengikat ke layanan, baca Ringkasan layanan terikat.
Berikut adalah beberapa kode contoh yang menunjukkan pemanggilan layanan yang dibuat AIDL, yang diambil dari contoh Layanan Jarak Jauh dalam project 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) } } } }