Layanan terikat adalah server di antarmuka klien-server. Ini memungkinkan komponen seperti aktivitas yang terikat ke layanan, mengirim permintaan, menerima respons, dan melakukan komunikasi antarproses (IPC). Layanan terikat biasanya aktif hanya saat melayani komponen aplikasi lain dan tidak berjalan di latar belakang terus-menerus.
Dokumen ini menjelaskan cara membuat layanan terikat, termasuk cara mengikat ke layanan dari komponen aplikasi lain. Untuk informasi tambahan tentang layanan di umum, seperti cara mengirimkan notifikasi dari layanan dan mengatur layanan agar berjalan di latar depan, lihat Ringkasan layanan.
Dasar-dasar
Layanan terikat adalah implementasi class Service
yang memungkinkan
aplikasi lain mengikatnya dan
berinteraksi dengannya. Untuk menyediakan pengikatan bagi
Anda akan menerapkan metode callback onBind()
. Metode
ini menampilkan objek IBinder
yang mendefinisikan antarmuka pemrograman yang
dapat digunakan klien untuk berinteraksi dengan layanan.
Mengikat ke layanan yang sudah dimulai
Seperti yang telah dibahas dalam Ringkasan layanan,
Anda dapat membuat layanan
yang dimulai dan terikat. Artinya, Anda dapat memulai
layanan dengan memanggil startService()
, yang memungkinkan
dan layanan berjalan tanpa batas waktu. Anda juga dapat mengizinkan klien
mengikat ke layanan dengan
memanggil bindService()
.
Jika Anda membiarkan layanan dimulai dan
diikat, lalu saat layanan dimulai,
sistem tidak menghancurkan layanan ketika semua klien melepas ikatan.
Sebaliknya, Anda harus menghentikan layanan secara eksplisit, dengan memanggil stopSelf()
atau stopService()
.
Meskipun biasanya Anda harus mengimplementasikan
onBind()
atau onStartCommand()
, terkadang
perlu untuk
mengimplementasikan keduanya. Misalnya, pemutar musik dapat merasa terbantu jika layanannya berjalan
tanpa batas waktu dan juga menyediakan pengikatan. Dengan cara ini, suatu aktivitas dapat memulai
layanan untuk memutar beberapa
musik, dan musik akan terus diputar meskipun pengguna keluar dari aplikasi. Lalu, saat pengguna
kembali ke aplikasi, aktivitas dapat mengikat ke layanan untuk mendapatkan kembali kontrol
pemutaran.
Untuk informasi selengkapnya tentang daur hidup layanan saat menambahkan pengikatan ke layanan yang sudah dimulai, lihat bagian Mengelola siklus proses layanan terikat.
Klien mengikat ke layanan dengan memanggil
bindService()
. Bila itu dilakukan, klien harus
menyediakan implementasi ServiceConnection
, yang akan
memantau koneksi dengan layanan. Nilai hasil
bindService()
menunjukkan apakah
layanan yang diminta ada dan apakah klien diziinkan mengaksesnya.
Kapan
sistem Android membuat koneksi antara klien dan layanan, maka
menelepon onServiceConnected()
pada ServiceConnection
. Tujuan
Metode onServiceConnected()
menyertakan IBinder
, yang kemudian digunakan klien untuk berkomunikasi dengan layanan terikat.
Anda dapat menghubungkan beberapa klien ke layanan secara bersamaan. Namun, sistem
melakukan cache pada saluran komunikasi layanan IBinder
.
Dengan kata lain, sistem akan memanggil onBind()
layanan
untuk menghasilkan IBinder
, hanya jika metode
pengikatan klien. Sistem kemudian memberikan IBinder
yang sama ke
semua klien tambahan yang mengikat ke layanan yang sama, tanpa memanggil
onBind()
lagi.
Ketika klien terakhir melepas ikatan dari layanan, sistem akan menghapus layanan, kecuali jika
layanan mulai menggunakan startService()
.
Bagian terpenting dari implementasi layanan terikat Anda adalah mendefinisikan antarmuka yang dikembalikan metode callback onBind()
Anda. Hal berikut
ini membahas beberapa cara untuk menentukan
Antarmuka IBinder
.
Membuat layanan terikat
Saat membuat layanan yang menyediakan pengikatan, Anda harus menyediakan IBinder
yang menyediakan antarmuka pemrograman yang dapat digunakan klien untuk berinteraksi dengan layanan. Ada
tiga cara untuk menentukan antarmuka:
- Memperluas class Binder
- Jika layanan Anda bersifat pribadi untuk aplikasi Anda sendiri dan berjalan dalam proses yang sama
sebagai klien, yang pada umumnya, buat antarmuka Anda dengan memperluas
Binder
kelas dan mengembalikan instance darionBind()
. Klien akan menerimaBinder
dan dapat menggunakannya untuk mengakses langsung metode publik yang tersedia dalam implementasiBinder
atauService
.Inilah teknik yang lebih disukai bila layanan Anda sekadar pekerja latar belakang untuk aplikasi Anda sendiri. Satu-satunya kasus penggunaan saat ini bukan cara yang direkomendasikan untuk membuat antarmuka Anda adalah jika layanan Anda digunakan oleh aplikasi lain atau pada proses terpisah.
- Menggunakan Messenger
- Jika antarmuka Anda perlu bekerja lintas proses yang berbeda, Anda dapat membuat
antarmuka untuk layanan dengan
Messenger
. Dengan cara ini, layanan mendefinisikanHandler
yang akan merespons berbagai tipe objekMessage
.Handler
ini adalah dasar untukMessenger
yang kemudian dapat membagikanIBinder
dengan klien, sehingga klien dapat mengirim perintah ke layanan menggunakan objekMessage
. Selain itu, klien dapat menentukanMessenger
dari sendiri, sehingga layanan dapat mengirim pesan balik.Inilah cara termudah melakukan komunikasi antarproses (IPC), karena
Messenger
akan membuat antrean semua permintaan ke dalam satu thread, sehingga Anda tidak perlu mendesain layanan agar thread-safe. - Menggunakan AIDL
- Android Interface Definition Language (AIDL) menguraikan objek menjadi
primitif yang dapat dipahami dan diarahkan oleh sistem operasi
ke seluruh proses untuk melakukan
IPC. Teknik sebelumnya, yang menggunakan
Messenger
, sebenarnya didasarkan pada AIDL yang menjadi struktur dasarnya.Seperti disebutkan di bagian sebelumnya,
Messenger
membuat antrean semua permintaan klien dalam satu thread, sehingga layanan menerima permintaan satu per satu. Namun, jika ingin layanan Anda menangani beberapa permintaan sekaligus, Anda dapat menggunakan AIDL secara langsung. Dalam hal ini, layanan Anda harus aman untuk thread dan mampu melakukan multithreading.Untuk menggunakan AIDL secara langsung, membuat file
.aidl
yang menentukan antarmuka pemrograman. Android SDK Tools menggunakan file ini untuk menghasilkan class abstrak yang mengimplementasikan antarmuka dan menangani IPC, yang nantinya dapat Anda perluas dalam layanan.
Catatan: Untuk sebagian besar aplikasi, AIDL bukanlah pilihan terbaik untuk membuat layanan terikat, karena layanan itu mungkin memerlukan kemampuan multithreading dan dapat mengakibatkan implementasi yang lebih rumit. Oleh karena itu, dokumen ini tidak membahas bagaimana untuk menggunakannya dalam layanan Anda. Jika Anda yakin bahwa Anda perlu untuk menggunakan AIDL secara langsung, lihat AIDL dokumen.
Memperluas class Binder
Jika hanya aplikasi lokal yang
menggunakan layanan Anda dan itu tidak perlu
bekerja lintas proses,
Anda dapat mengimplementasikan class Binder
Anda sendiri yang memberi klien Anda
akses ke metode publik dalam layanan.
Catatan: Hal ini hanya berhasil jika klien dan layanan berada dalam aplikasi dan proses yang sama, suatu kondisi yang paling umum. Misalnya, ini cocok untuk musik aplikasi yang perlu mengikat aktivitas ke layanannya sendiri yang memutar musik di latar belakang.
Berikut cara menyiapkannya
- Dalam layanan Anda, buat sebuah instance
Binder
yang melakukan salah satu aktivitas berikut:- Menampung metode publik yang dapat dipanggil klien.
- Mengembalikan instance
Service
saat ini, yang memiliki metode publik yang dapat dipanggil klien. - Mengembalikan instance class lain yang di-host di layanan dengan metode publik yang dapat dipanggil klien.
- Mengembalikan instance
Binder
ini dari metode callbackonBind()
. - Di klien, terima
Binder
dari metode callbackonServiceConnected()
, lalu buat panggilan ke layanan terikat menggunakan metode yang disediakan.
Catatan: Layanan dan klien harus berada di aplikasi yang sama sehingga klien dapat mentransmisikan objek yang dikembalikan dan memanggil API-nya dengan benar. Layanan dan klien juga harus berada dalam proses yang sama, karena teknik ini tidak melakukan menjelajahi seluruh proses.
Misalnya, berikut adalah layanan yang memberi klien akses ke metode dalam layanan melalui
implementasi Binder
:
Kotlin
class LocalService : Service() { // Binder given to clients. private val binder = LocalBinder() // Random number generator. private val mGenerator = Random() /** Method for clients. */ val randomNumber: Int get() = mGenerator.nextInt(100) /** * Class used for the client Binder. Because we know this service always * runs in the same process as its clients, we don't need to deal with IPC. */ inner class LocalBinder : Binder() { // Return this instance of LocalService so clients can call public methods. fun getService(): LocalService = this@LocalService } override fun onBind(intent: Intent): IBinder { return binder } }
Java
public class LocalService extends Service { // Binder given to clients. private final IBinder binder = new LocalBinder(); // Random number generator. private final Random mGenerator = new Random(); /** * Class used for the client Binder. Because we know this service always * runs in the same process as its clients, we don't need to deal with IPC. */ public class LocalBinder extends Binder { LocalService getService() { // Return this instance of LocalService so clients can call public methods. return LocalService.this; } } @Override public IBinder onBind(Intent intent) { return binder; } /** Method for clients. */ public int getRandomNumber() { return mGenerator.nextInt(100); } }
LocalBinder
menyediakan metode getService()
bagi klien untuk mengambil
instance LocalService
saat ini. Hal ini memungkinkan klien memanggil metode publik di
layanan. Misalnya, klien dapat memanggil getRandomNumber()
dari layanan.
Berikut adalah aktivitas yang mengikat ke LocalService
dan memanggil getRandomNumber()
bila tombol diklik:
Kotlin
class BindingActivity : Activity() { private lateinit var mService: LocalService private var mBound: Boolean = false /** Defines callbacks for service binding, passed to bindService(). */ private val connection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // We've bound to LocalService, cast the IBinder and get LocalService instance. val binder = service as LocalService.LocalBinder mService = binder.getService() mBound = true } override fun onServiceDisconnected(arg0: ComponentName) { mBound = false } } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.main) } override fun onStart() { super.onStart() // Bind to LocalService. Intent(this, LocalService::class.java).also { intent -> bindService(intent, connection, Context.BIND_AUTO_CREATE) } } override fun onStop() { super.onStop() unbindService(connection) mBound = false } /** Called when a button is clicked (the button in the layout file attaches to * this method with the android:onClick attribute). */ fun onButtonClick(v: View) { if (mBound) { // Call a method from the LocalService. // However, if this call is something that might hang, then put this request // in a separate thread to avoid slowing down the activity performance. val num: Int = mService.randomNumber Toast.makeText(this, "number: $num", Toast.LENGTH_SHORT).show() } } }
Java
public class BindingActivity extends Activity { LocalService mService; boolean mBound = false; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override protected void onStart() { super.onStart(); // Bind to LocalService. Intent intent = new Intent(this, LocalService.class); bindService(intent, connection, Context.BIND_AUTO_CREATE); } @Override protected void onStop() { super.onStop(); unbindService(connection); mBound = false; } /** Called when a button is clicked (the button in the layout file attaches to * this method with the android:onClick attribute). */ public void onButtonClick(View v) { if (mBound) { // Call a method from the LocalService. // However, if this call is something that might hang, then put this request // in a separate thread to avoid slowing down the activity performance. int num = mService.getRandomNumber(); Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show(); } } /** Defines callbacks for service binding, passed to bindService(). */ private ServiceConnection connection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName className, IBinder service) { // We've bound to LocalService, cast the IBinder and get LocalService instance. LocalBinder binder = (LocalBinder) service; mService = binder.getService(); mBound = true; } @Override public void onServiceDisconnected(ComponentName arg0) { mBound = false; } }; }
Contoh sebelumnya menunjukkan cara klien mengikat ke layanan menggunakan implementasi
ServiceConnection
dan callback onServiceConnected()
. Bagian berikut
menyediakan informasi lebih lanjut tentang proses pengikatan ke layanan.
Catatan: Dalam contoh sebelumnya,
Metode onStop()
akan melepaskan klien dari layanan.
Melepaskan klien dari layanan pada waktu yang tepat, seperti yang dibahas dalam
Bagian Catatan tambahan.
Untuk kode contoh selengkapnya, lihat class
LocalService.java
dan class
LocalServiceActivities.java
dalam ApiDemos.
Menggunakan Messenger
Jika layanan perlu berkomunikasi dengan proses jauh, Anda dapat menggunakan
Messenger
untuk menyediakan antarmuka bagi layanan Anda. Teknik ini memungkinkan
Anda melakukan komunikasi antarproses (IPC)
tanpa perlu menggunakan AIDL.
Menggunakan Messenger
untuk antarmuka Anda
lebih mudah dibandingkan menggunakan AIDL karena
Messenger
membuat antrean semua panggilan ke layanan. Antarmuka AIDL murni mengirimkan permintaan bersamaan ke
, yang kemudian harus menangani multithreading.
Untuk sebagian besar aplikasi, layanan tidak perlu melakukan multithreading, jadi menggunakan Messenger
memungkinkan layanan menangani panggilan satu per satu. Jika penting
agar layanan Anda menjadi multi-thread, gunakan AIDL untuk menentukan antarmuka.
Berikut adalah ringkasan cara menggunakan Messenger
:
- Layanan mengimplementasikan
Handler
yang menerima callback untuk setiap panggilan dari klien. - Layanan menggunakan
Handler
untuk membuat objekMessenger
(yang merupakan acuan keHandler
). Messenger
membuatIBinder
yang dikembalikan layanan ke klien darionBind()
.- Klien menggunakan
IBinder
untuk membuat instanceMessenger
(yang mengacuHandler
layanan), yang digunakan klien untuk mengirim objekMessage
ke layanan. - Layanan menerima setiap
Message
dalamHandler
secara spesifik, dalam metodehandleMessage()
.
Dengan cara ini, tidak ada metode untuk dipanggil klien pada layanan. Sebagai gantinya,
klien mengirim pesan (objek Message
) yang diterima
layanan dalam
Handler
-nya.
Berikut adalah contoh layanan sederhana yang menggunakan antarmuka Messenger
:
Kotlin
/** Command to the service to display a message. */ private const val MSG_SAY_HELLO = 1 class MessengerService : Service() { /** * Target we publish for clients to send messages to IncomingHandler. */ private lateinit var mMessenger: Messenger /** * Handler of incoming messages from clients. */ internal class IncomingHandler( context: Context, private val applicationContext: Context = context.applicationContext ) : Handler() { override fun handleMessage(msg: Message) { when (msg.what) { MSG_SAY_HELLO -> Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show() else -> super.handleMessage(msg) } } } /** * When binding to the service, we return an interface to our messenger * for sending messages to the service. */ override fun onBind(intent: Intent): IBinder? { Toast.makeText(applicationContext, "binding", Toast.LENGTH_SHORT).show() mMessenger = Messenger(IncomingHandler(this)) return mMessenger.binder } }
Java
public class MessengerService extends Service { /** * Command to the service to display a message. */ static final int MSG_SAY_HELLO = 1; /** * Handler of incoming messages from clients. */ static class IncomingHandler extends Handler { private Context applicationContext; IncomingHandler(Context context) { applicationContext = context.getApplicationContext(); } @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_SAY_HELLO: Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show(); break; default: super.handleMessage(msg); } } } /** * Target we publish for clients to send messages to IncomingHandler. */ Messenger mMessenger; /** * When binding to the service, we return an interface to our messenger * for sending messages to the service. */ @Override public IBinder onBind(Intent intent) { Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show(); mMessenger = new Messenger(new IncomingHandler(this)); return mMessenger.getBinder(); } }
Metode handleMessage()
di
Handler
adalah tempat layanan menerima Message
yang masuk
dan memutuskan tindakan yang harus dilakukan, berdasarkan anggota what
.
Klien tinggal membuat Messenger
berdasarkan IBinder
yang dikembalikan oleh layanan dan mengirim pesan menggunakan send()
. Misalnya, berikut adalah aktivitas yang mengikat ke
dan mengirimkan pesan MSG_SAY_HELLO
ke layanan:
Kotlin
class ActivityMessenger : Activity() { /** Messenger for communicating with the service. */ private var mService: Messenger? = null /** Flag indicating whether we have called bind on the service. */ private var bound: 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 has been // established, giving us the object we can use to // interact with the service. We are communicating with the // service using a Messenger, so here we get a client-side // representation of that from the raw IBinder object. mService = Messenger(service) bound = true } override fun onServiceDisconnected(className: ComponentName) { // This is called when the connection with the service has been // unexpectedly disconnected—that is, its process crashed. mService = null bound = false } } fun sayHello(v: View) { if (!bound) return // Create and send a message to the service, using a supported 'what' value. val msg: Message = Message.obtain(null, MSG_SAY_HELLO, 0, 0) try { mService?.send(msg) } catch (e: RemoteException) { e.printStackTrace() } } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.main) } override fun onStart() { super.onStart() // Bind to the service. Intent(this, MessengerService::class.java).also { intent -> bindService(intent, mConnection, Context.BIND_AUTO_CREATE) } } override fun onStop() { super.onStop() // Unbind from the service. if (bound) { unbindService(mConnection) bound = false } } }
Java
public class ActivityMessenger extends Activity { /** Messenger for communicating with the service. */ Messenger mService = null; /** Flag indicating whether we have called bind on the service. */ boolean bound; /** * Class for interacting with the main interface of the service. */ private ServiceConnection mConnection = new ServiceConnection() { public void onServiceConnected(ComponentName className, IBinder service) { // This is called when the connection with the service has been // established, giving us the object we can use to // interact with the service. We are communicating with the // service using a Messenger, so here we get a client-side // representation of that from the raw IBinder object. mService = new Messenger(service); bound = true; } public void onServiceDisconnected(ComponentName className) { // This is called when the connection with the service has been // unexpectedly disconnected—that is, its process crashed. mService = null; bound = false; } }; public void sayHello(View v) { if (!bound) return; // Create and send a message to the service, using a supported 'what' value. Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0); try { mService.send(msg); } catch (RemoteException e) { e.printStackTrace(); } } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } @Override protected void onStart() { super.onStart(); // Bind to the service. bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE); } @Override protected void onStop() { super.onStop(); // Unbind from the service. if (bound) { unbindService(mConnection); bound = false; } } }
Contoh ini tidak menunjukkan cara layanan merespons klien.
Jika ingin layanan
merespons, Anda juga perlu membuat Messenger
di klien.
Saat klien menerima callback onServiceConnected()
, klien akan mengirim Message
ke layanan yang berisi Messenger
klien dalam parameter replyTo
metode send()
.
Anda dapat melihat contoh cara menyediakan fitur pesan dua arah dalam contoh
MessengerService.java
(layanan) dan
MessengerServiceActivities.java
(klien).
Mengikat ke layanan
Komponen aplikasi (klien) dapat mengikat ke layanan dengan memanggil
bindService()
. Sistem Android
kemudian memanggil onBind()
layanan, yang mengembalikan IBinder
untuk berinteraksi
dengan layanan.
Pengikatan tersebut asinkron, dan bindService()
segera kembali tanpa mengembalikan IBinder
ke
klien. Untuk menerima IBinder
, klien harus membuat
instance ServiceConnection
dan meneruskannya ke bindService()
. ServiceConnection
berisi metode callback yang dipanggil sistem
untuk mengirim IBinder
.
Catatan: Hanya aktivitas, layanan, dan penyedia konten yang dapat mengikat ke layanan, yang tidak dapat Anda ikat ke layanan dari penerima siaran.
Jadi, untuk mengikat layanan dari klien, Anda harus:
- Mengimplementasikan
ServiceConnection
.Implementasi Anda harus mengganti dua metode callback:
onServiceConnected()
- Sistem memanggil ini untuk mengirim
IBinder
yang dikembalikan oleh metodeonBind()
layanan. onServiceDisconnected()
- Sistem Android memanggilnya saat terhubung ke layanan secara tidak terduga hilang, seperti saat layanan mengalami error atau dimatikan. Ini tidak dipanggil saat klien melepas ikatan.
- Panggil
bindService()
, dengan meneruskan implementasiServiceConnection
.Catatan: Jika metode ini mengembalikan false, berarti klien Anda tidak memiliki koneksi yang valid ke layanan. Namun, panggil
unbindService()
pada klien Anda. Jika tidak, klien Anda akan menjaga layanan dari mematikannya saat tidak ada aktivitas. - Bila sistem memanggil metode callback
onServiceConnected()
, Anda dapat mulai membuat panggilan ke layanan, menggunakan metode yang ditetapkan oleh antarmuka. - Untuk memutus koneksi dari layanan, panggil
unbindService()
.Jika klien Anda tetap terikat ke layanan saat aplikasi Anda menghapus klien, penghapusan tersebut akan menyebabkan ikatan klien terputus. Praktik yang lebih baik adalah melepaskan klien segera setelah selesai berinteraksi dengan layanan. Tindakan ini akan membuat layanan yang tidak ada aktivitas dapat dimatikan. Untuk informasi lebih lanjut tentang waktu yang tepat untuk mengikat dan melepas ikatan, lihat bagian Catatan tambahan.
Contoh berikut menghubungkan klien ke layanan yang dibuat sebelumnya oleh
memperluas class Binder, sehingga yang perlu dilakukan hanyalah mentransmisikan
IBinder
ke class LocalBinder
dan meminta instance LocalService
:
Kotlin
var mService: LocalService val mConnection = object : ServiceConnection { // Called when the connection with the service is established. override fun onServiceConnected(className: ComponentName, service: IBinder) { // Because we have bound to an explicit // service that is running in our own process, we can // cast its IBinder to a concrete class and directly access it. val binder = service as LocalService.LocalBinder mService = binder.getService() mBound = true } // Called when the connection with the service disconnects unexpectedly. override fun onServiceDisconnected(className: ComponentName) { Log.e(TAG, "onServiceDisconnected") mBound = false } }
Java
LocalService mService; private ServiceConnection mConnection = new ServiceConnection() { // Called when the connection with the service is established. public void onServiceConnected(ComponentName className, IBinder service) { // Because we have bound to an explicit // service that is running in our own process, we can // cast its IBinder to a concrete class and directly access it. LocalBinder binder = (LocalBinder) service; mService = binder.getService(); mBound = true; } // Called when the connection with the service disconnects unexpectedly. public void onServiceDisconnected(ComponentName className) { Log.e(TAG, "onServiceDisconnected"); mBound = false; } };
Dengan ServiceConnection
ini, klien bisa mengikat ke layanan dengan meneruskannya
ke bindService()
, seperti yang ditampilkan pada contoh berikut:
Kotlin
Intent(this, LocalService::class.java).also { intent -> bindService(intent, connection, Context.BIND_AUTO_CREATE) }
Java
Intent intent = new Intent(this, LocalService.class); bindService(intent, connection, Context.BIND_AUTO_CREATE);
- Parameter pertama
bindService()
adalahIntent
yang secara eksplisit menyebutkan layanan yang akan diikat.Perhatian: Jika Anda menggunakan intent untuk mengikat ke
Service
, pastikan aplikasi Anda aman dengan menggunakan eksplisit intent. Menggunakan maksud implisit untuk memulai layanan adalah bahaya keamanan karena Anda tidak dapat memastikan layanan apa yang akan merespons maksud tersebut, dan pengguna tidak dapat melihat layanan mana yang dimulai. Mulai dari Android 5.0 (API level 21), sistem akan melontarkan pengecualian jika Anda memanggilbindService()
dengan intent implisit. - Parameter kedua adalah objek
ServiceConnection
. - Parameter ketiga adalah flag yang menunjukkan opsi untuk binding—biasanya
BIND_AUTO_CREATE
, untuk membuat layanan jika belum hidup. Nilai lain yang mungkin adalahBIND_DEBUG_UNBIND
,BIND_NOT_FOREGROUND
, atau0
jika tidak satu pun.
Catatan tambahan
Berikut ini beberapa catatan penting tentang pengikatan ke layanan:
- Selalu menjebak pengecualian
DeadObjectException
, yang ditampilkan ketika koneksi terputus. Inilah satu-satunya pengecualian yang dilontarkan oleh metode jauh. - Objek adalah acuan yang dihitung lintas proses.
- Anda biasanya memasangkan
pengikatan dan pelepasan ikatan selama
mencocokkan momen memunculkan dan
pembongkaran dari siklus hidup klien, seperti yang
contoh berikut:
- Jika Anda perlu berinteraksi dengan layanan hanya saat aktivitas terlihat, lakukan binding selama
onStart()
dan lepaskan selamaonStop()
. - Jika Anda ingin aktivitas menerima respons bahkan saat dihentikan di
latar belakang, mengikat selama
onCreate()
dan melepas ikatan selamaonDestroy()
. Berhati-hatilah karena hal ini menyiratkan bahwa perlu menggunakan layanan selama layanan itu berjalan, bahkan di latar belakang, jadi ketika layanan berada dalam proses lain, maka Anda meningkatkan bobot proses dan itu kemungkinan besar akan dimatikan oleh sistem.
Catatan: Anda biasanya tidak mengikat dan melepas ikatan selama callback
onResume()
danonPause()
aktivitas, karena callback ini terjadi setiap membuat transisi siklus proses. Minimalkan pemrosesan yang terjadi pada transisi ini.Selain itu, jika beberapa aktivitas di aplikasi Anda terikat ke layanan yang sama dan ada transisi antara dua aktivitas tersebut, layanan mungkin dihancurkan dan dibuat ulang sebagai pelepasan ikatan aktivitas (selama jeda) sebelum yang berikutnya mengikat (selama melanjutkan). Transisi aktivitas ini untuk menentukan aktivitas yang mengoordinasikan siklus prosesnya dijelaskan dalam Siklus proses aktivitas.
- Jika Anda perlu berinteraksi dengan layanan hanya saat aktivitas terlihat, lakukan binding selama
Untuk kode contoh lain yang menunjukkan cara mengikat ke layanan, lihat
RemoteService.java
dalam ApiDemos.
Mengelola siklus proses layanan terikat
Jika layanan dilepas ikatannya dari semua klien, sistem Android akan menghapusnya
(kecuali jika mereka mulai menggunakan
startService()
).
Jadi, Anda tidak perlu mengelola
siklus hidup layanan Anda jika
sepenuhnya merupakan layanan terikat. Sistem Android mengelolanya berdasarkan
apakah terikat ke klien mana pun.
Namun, jika memilih untuk mengimplementasikan metode callback onStartCommand()
, Anda harus menghentikan layanan secara eksplisit, karena
layanan kini dianggap dimulai. Dalam hal ini, layanan akan berjalan hingga
menghentikan dirinya sendiri dengan stopSelf()
atau komponen lain memanggil stopService()
, terlepas dari apakah
layanan terikat ke klien atau tidak.
Selain itu, jika layanan Anda dimulai dan menerima pengikatan, maka saat sistem memanggil
metode onUnbind()
, Anda juga dapat menampilkan
true
jika Anda ingin menerima panggilan ke onRebind()
saat klien mengikat ke layanan lagi. onRebind()
tidak mengembalikan apa-apa, namun klien masih menerima IBinder
dalam
callback onServiceConnected()
.
Gambar di bawah ini mengilustrasikan logika untuk jenis siklus proses ini.
![](https://developer.android.google.cn/static/images/fundamentals/service_binding_tree_lifecycle.png?authuser=9&hl=id)
Gambar 1. Siklus proses untuk layanan yang dimulai dan juga mengizinkan pengikatan.
Untuk mengetahui informasi selengkapnya tentang siklus proses layanan yang telah dimulai, lihat Ringkasan layanan.