{@link android.app.Service} adalah sebuah komponen aplikasi yang bisa melakukan operasi yang berjalan lama di latar belakang dan tidak menyediakan antarmuka pengguna. Komponen aplikasi lain bisa memulai layanan dan komponen aplikasi tersebut akan terus berjalan di latar belakang walaupun pengguna beralih ke aplikasi lain. Selain itu, komponen bisa mengikat ke layanan untuk berinteraksi dengannya dan bahkan melakukan komunikasi antarproses (IPC). Misalnya, layanan mungkin menangani transaksi jaringan, memutar musik, melakukan file I/O, atau berinteraksi dengan penyedia konten dari latar belakang.
Ada dua bentuk dasar layanan:
Walaupun dokumentasi ini secara umum membahas kedua jenis layanan secara terpisah, layanan Anda bisa menggunakan keduanya—layanan bisa dimulai (untuk berjalan terus-menerus) sekaligus memungkinkan pengikatan. Cukup mengimplementasikan dua metode callback: {@link android.app.Service#onStartCommand onStartCommand()} untuk memungkinkan komponen memulainya dan {@link android.app.Service#onBind onBind()} untuk memungkinkan pengikatan.
Apakah aplikasi Anda sudah dimulai, terikat, atau keduanya, semua komponen aplikasi bisa menggunakan layanan (bahkan dari aplikasi terpisah), demikian pula semua komponen bisa menggunakan suatu aktivitas—dengan memulainya dengan {@link android.content.Intent}. Akan tetapi, Anda bisa mendeklarasikan layanan sebagai privat, pada file manifes, dan memblokir akses dari aplikasi lain. Hal ini dibahas selengkapnya di bagian tentang Mendeklarasikan layanan dalam manifes.
Perhatian: Layanan berjalan di thread utama proses yang menjadi host-nya—layanan tidak membuat thread-nya sendiri dan tidak berjalan pada proses terpisah (kecuali bila Anda tentukan demikian). Artinya, jika layanan Anda akan melakukan pekerjaan yang membutuhkan tenaga CPU besar atau operasi yang memblokir (seperti pemutaran MP3 atau jaringan), Anda perlu membuat thread baru dalam layanan untuk melakukan pekerjaan tersebut. Dengan menggunakan thread terpisah, Anda mengurangi risiko terjadinya kesalahan Aplikasi Tidak Merespons (Application Not Responding/ANR) dan thread utama aplikasi bisa tetap dikhususkan pada interaksi pengguna dengan aktivitas Anda.
Layanan sekadar komponen yang bisa berjalan di latar belakang walaupun pengguna sedang tidak berinteraksi dengan aplikasi Anda. Sehingga, Anda harus membuat layanan bila memang itu yang dibutuhkan.
Bila Anda perlu melakukan pekerjaan di luar thread utama, namun hanya bila pengguna sedang berinteraksi dengan aplikasi, maka Anda harus membuat thread baru sebagai ganti layanan baru. Misalnya, bila Anda ingin memutar musik, namun hanya saat aktivitas Anda berjalan, Anda bisa membuat thread dalam {@link android.app.Activity#onCreate onCreate()}, mulai menjalankannya di {@link android.app.Activity#onStart onStart()}, kemudian menghentikannya di {@link android.app.Activity#onStop onStop()}. Pertimbangkan juga untuk menggunakan {@link android.os.AsyncTask} atau {@link android.os.HandlerThread}, sebagai ganti kelas {@link java.lang.Thread} yang lazim digunakan. Lihat dokumen Proses dan Threading untuk informasi selengkapnya tentang thread.
Ingatlah jika menggunakan layanan, layanan tersebut tetap berjalan di thread utama aplikasi Anda secara default, jadi Anda harus tetap membuat thread baru dalam layanan bila layanan tersebut melakukan operasi yang intensif atau operasi yang memblokir.
Untuk membuat layanan, Anda harus membuat subkelas {@link android.app.Service} (atau salah satu dari subkelasnya yang ada). Dalam implementasi, Anda perlu mengesampingkan sebagian metode callback yang menangani aspek utama daur hidup layanan dan memberikan mekanisme bagi komponen untuk mengikat pada layanan, bila dibutuhkan. Metode callback terpenting yang perlu Anda kesampingkan adalah:
Bila komponen memulai layanan dengan memanggil {@link android.content.Context#startService startService()} (yang menyebabkan panggilan ke {@link android.app.Service#onStartCommand onStartCommand()}), maka layanan terus berjalan hingga terhenti sendiri dengan {@link android.app.Service#stopSelf()} atau bila komponen lain menghentikannya dengan memanggil {@link android.content.Context#stopService stopService()}.
Bila komponen memanggil {@link android.content.Context#bindService bindService()} untuk membuat layanan (dan {@link android.app.Service#onStartCommand onStartCommand()} tidak dipanggil), maka layanan hanya berjalan selama komponen terikat kepadanya. Setelah layanan dilepas ikatannya dari semua klien, sistem akan menghancurkannya.
Sistem Android akan menghentikan paksa layanan hanya bila memori tinggal sedikit dan sistem harus memulihkan sumber daya sistem untuk aktivitas yang mendapatkan fokus pengguna. Jika layanan terikat pada suatu aktivitas yang mendapatkan fokus pengguna, layanan tersebut lebih kecil kemungkinannya untuk dimatikan, dan jika layanan dideklarasikan untuk berjalan di latar depan (akan dibahas kemudian), maka sudah hampir pasti ia tidak akan dimatikan. Sebaliknya, bila layanan sudah dimulai dan berjalan lama, maka sistem akan menurunkan posisinya dalam daftar tugas latar belakang seiring waktu dan layanan akan sangat rentan untuk dimatikan—bila layanan Anda dimulai, maka Anda harus mendesainnya agar bisa menangani restart oleh sistem dengan baik. Jika sistem mematikan layanan Anda, layanan akan dimulai kembali begitu sumber daya kembali tersedia (tetapi ini juga bergantung pada nilai yang Anda kembalikan dari {@link android.app.Service#onStartCommand onStartCommand()}, sebagaimana akan dibahas nanti). Untuk informasi selengkapnya tentang kapan sistem mungkin akan memusnahkan layanan, lihat dokumen Proses dan Threading.
Dalam bagian selanjutnya, Anda akan melihat bagaimana membuat masing-masing tipe layanan dan cara menggunakannya dari komponen aplikasi lain.
Sebagaimana aktivitas (dan komponen lainnya), Anda harus mendeklarasikan semua layanan dalam file manifes aplikasi Anda.
Untuk mendeklarasikan layanan Anda, tambahkan sebuah elemen {@code <service>} sebagai anak elemen {@code <application>}. Misalnya:
<manifest ... >
...
<application ... >
<service android:name=".ExampleService" />
...
</application>
</manifest>
Lihat acuan elemen {@code <service>} untuk informasi selengkapnya tentang cara mendeklarasikan layanan Anda dalam manifes.
Ada atribut lain yang bisa Anda sertakan dalam elemen {@code <service>} untuk mendefinisikan properti seperti izin yang dibutuhkan untuk memulai layanan dan proses tempat berjalannya layanan. {@code android:name} adalah satu-satunya atribut yang diperlukan —atribut tersebut menetapkan nama kelas layanan. Setelah mempublikasikan aplikasi, Anda tidak boleh mengubah nama ini, karena jika melakukannya, Anda bisa merusak kode karena dependensi terhadap intent eksplisit untuk memulai atau mengikat layanan (bacalah posting blog berjudul Things That Cannot Change).
Untuk memastikan aplikasi Anda aman, selalu gunakan intent eksplisit saat memulai atau mengikat {@link android.app.Service} Anda dan jangan mendeklarasikan filter intent untuk layanan. Jika Anda perlu membiarkan adanya ambiguitas tentang layanan mana yang dimulai, Anda bisa menyediakan filter intent bagi layanan dan tidak memasukkan nama komponen pada {@link android.content.Intent}, namun Anda juga harus menyesuaikan paket bagi intent tersebut dengan {@link android.content.Intent#setPackage setPackage()}, yang memberikan klarifikasi memadai bagi target layanan.
Anda juga bisa memastikan layanan tersedia hanya bagi aplikasi Anda dengan menyertakan atribut {@code android:exported} dan mengaturnya ke {@code "false"}. Hal ini efektif menghentikan aplikasi lain agar tidak memulai layanan Anda, bahkan saat menggunakan intent eksplisit.
Layanan yang sudah dimulai adalah layanan yang dimulai komponen lain dengan memanggil {@link android.content.Context#startService startService()}, yang menyebabkan panggilan ke metode {@link android.app.Service#onStartCommand onStartCommand()} layanan.
Bila layanan sudah dimulai, layanan tersebut memiliki daur hidup yang tidak bergantung pada komponen yang memulainya dan bisa berjalan terus-menerus di latar belakang walaupun komponen yang memulainya dimusnahkan. Dengan sendirinya, layanan akan berhenti sendiri bila pekerjaannya selesai dengan memanggil {@link android.app.Service#stopSelf stopSelf()}, atau komponen lain bisa menghentikannya dengan memanggil {@link android.content.Context#stopService stopService()}.
Komponen aplikasi seperti aktivitas bisa memulai layanan dengan memanggil {@link android.content.Context#startService startService()} dan meneruskan {@link android.content.Intent} yang menetapkan layanan dan menyertakan data untuk digunakan layanan. Layanan menerima {@link android.content.Intent} ini dalam metode {@link android.app.Service#onStartCommand onStartCommand()}.
Sebagai contoh, anggaplah aktivitas perlu menyimpan data ke database online. Aktivitas tersebut bisa memulai layanan pendamping dan mengiriminya data untuk disimpan dengan meneruskan intent ke {@link android.content.Context#startService startService()}. Layanan akan menerima intent dalam {@link android.app.Service#onStartCommand onStartCommand()}, menghubungkan ke Internet dan melakukan transaksi database. Bila transaksi selesai, layanan akan berhenti sendiri dan dimusnahkan.
Perhatian: Layanan berjalan dalam proses yang sama dengan aplikasi tempatnya dideklarasikan dan dalam thread utama aplikasi tersebut, secara default. Jadi, bila layanan Anda melakukan operasi yang intensif atau operasi pemblokiran saat pengguna berinteraksi dengan aktivitas dari aplikasi yang sama, layanan akan memperlambat kinerja aktivitas. Agar tidak memengaruhi kinerja aplikasi, Anda harus memulai thread baru di dalam layanan.
Biasanya, ada dua kelas yang bisa Anda perluas untuk membuat layanan yang sudah dimulai:
Bagian selanjutnya membahas cara mengimplementasikan layanan Anda menggunakan salah satu dari kelas-kelas ini.
Mengingat kebanyakan layanan yang sudah dimulai tidak perlu menangani beberapa permintaan sekaligus (yang bisa berupa skenario multi-threading berbahaya), mungkin Anda sebaiknya mengimplementasikan layanan menggunakan kelas {@link android.app.IntentService}.
Berikut ini yang dilakukan {@link android.app.IntentService}:
Oleh karena itu, Anda hanya perlu mengimplementasikan {@link android.app.IntentService#onHandleIntent onHandleIntent()} untuk melakukan pekerjaan yang diberikan oleh klien. (Akan tetapi, Anda juga perlu menyediakan konstruktor kecil bagi layanan.)
Berikut ini contoh implementasi {@link android.app.IntentService}:
public class HelloIntentService extends IntentService {
/**
* A constructor is required, and must call the super {@link android.app.IntentService#IntentService}
* constructor with a name for the worker thread.
*/
public HelloIntentService() {
super("HelloIntentService");
}
/**
* The IntentService calls this method from the default worker thread with
* the intent that started the service. When this method returns, IntentService
* stops the service, as appropriate.
*/
@Override
protected void onHandleIntent(Intent intent) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
}
}
Anda hanya memerlukan: konstruktor dan implementasi {@link android.app.IntentService#onHandleIntent onHandleIntent()}.
Jika Anda memutuskan untuk juga mengesampingkan metode callback lain, seperti {@link android.app.IntentService#onCreate onCreate()}, {@link android.app.IntentService#onStartCommand onStartCommand()}, atau {@link android.app.IntentService#onDestroy onDestroy()}, pastikan memanggil implementasi super, sehingga {@link android.app.IntentService} bisa menangani hidup thread pekerja dengan baik.
Misalnya, {@link android.app.IntentService#onStartCommand onStartCommand()} harus mengembalikan implementasi default (yang merupakan cara penyampaian intent ke {@link android.app.IntentService#onHandleIntent onHandleIntent()}):
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
return super.onStartCommand(intent,flags,startId);
}
Selain {@link android.app.IntentService#onHandleIntent onHandleIntent()}, satu-satunya metode lain yang tidak mengharuskan Anda memanggil super kelas adalah {@link android.app.IntentService#onBind onBind()} (namun Anda hanya perlu mengimplementasikannya bila layanan mengizinkan pengikatan).
Dalam bagian berikutnya, Anda akan melihat bagaimana layanan serupa diimplementasikan saat memperluas kelas {@link android.app.Service} basis, yang membutuhkan kode lebih banyak lagi, namun mungkin cocok jika Anda perlu menangani beberapa permintaan memulai sekaligus.
Seperti telah Anda lihat di bagian sebelumnya, menggunakan {@link android.app.IntentService} membuat implementasi layanan yang sudah dimulai jadi sangat sederhana. Namun, bila Anda mengharuskan layanan untuk melakukan multi-threading (sebagai ganti memproses permintaan memulai melalui antrean pekerjaan), maka Anda bisa memperluas kelas {@link android.app.Service} untuk menangani masing-masing intent.
Sebagai perbandingan, contoh kode berikut ini adalah implementasi kelas {@link android.app.Service} yang melakukan pekerjaan yang persis sama dengan contoh di atas menggunakan {@link android.app.IntentService}. Artinya, untuk setiap permintaan memulai, kode tersebut akan menggunakan thread pekerja untuk melakukan pekerjaan dan memproses permintaan satu per satu.
public class HelloService extends Service {
private Looper mServiceLooper;
private ServiceHandler mServiceHandler;
// Handler that receives messages from the thread
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
// Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
stopSelf(msg.arg1);
}
}
@Override
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work will not disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
// For each start request, send a message to start a job and deliver the
// start ID so we know which request we're stopping when we finish the job
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
mServiceHandler.sendMessage(msg);
// If we get killed, after returning from here, restart
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
// We don't provide binding, so return null
return null;
}
@Override
public void onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
}
}
Seperti yang bisa Anda lihat, ini membutuhkan lebih banyak pekerjaan daripada menggunakan {@link android.app.IntentService}.
Akan tetapi, karena Anda menangani sendiri setiap panggilan ke {@link android.app.Service#onStartCommand onStartCommand()}, Anda bisa melakukan beberapa permintaan sekaligus. Itu bukan yang dilakukan contoh ini, namun jika itu yang diinginkan, Anda bisa membuat thread baru untuk setiap permintaan dan langsung menjalankannya (sebagai ganti menunggu permintaan sebelumnya selesai).
Perhatikan bahwa metode {@link android.app.Service#onStartCommand onStartCommand()} harus mengembalikan integer. Integer tersebut merupakan nilai yang menjelaskan cara sistem melanjutkan layanan dalam kejadian yang dimatikan oleh sistem (sebagaimana dibahas di atas, implementasi default {@link android.app.IntentService} menangani hal ini untuk Anda, walaupun Anda bisa memodifikasinya). Nilai yang dikembalikan dari {@link android.app.Service#onStartCommand onStartCommand()} harus berupa salah satu konstanta berikut ini:
Untuk detail selengkapnya tentang nilai pengembalian ini, lihat dokumentasi acuan untuk setiap konstanta.
Anda bisa memulai layanan dari aktivitas atau komponen aplikasi lain dengan meneruskan {@link android.content.Intent} (yang menetapkan layanan yang akan dimulai) ke {@link android.content.Context#startService startService()}. Sistem Android akan memanggil metode {@link android.app.Service#onStartCommand onStartCommand()} layanan dan meneruskan {@link android.content.Intent} padanya. (Jangan sekali-kali memanggil {@link android.app.Service#onStartCommand onStartCommand()} secara langsung.)
Misalnya, aktivitas bisa memulai contoh layanan di bagian sebelumnya ({@code HelloSevice}) menggunakan intent eksplisit dengan {@link android.content.Context#startService startService()}:
Intent intent = new Intent(this, HelloService.class); startService(intent);
Metode {@link android.content.Context#startService startService()} segera kembali dan sistem Android akan memanggil metode {@link android.app.Service#onStartCommand onStartCommand()} layanan. Jika layanan belum berjalan, sistem mula-mula memanggil {@link android.app.Service#onCreate onCreate()}, kemudian memanggil {@link android.app.Service#onStartCommand onStartCommand()}.
Jika layanan juga tidak menyediakan pengikatan, intent yang disampaikan dengan {@link android.content.Context#startService startService()} adalah satu-satunya mode komunikasi antara komponen aplikasi dan layanan. Akan tetapi, jika Anda ingin agar layanan mengirimkan hasilnya kembali, maka klien yang memulai layanan bisa membuat {@link android.app.PendingIntent} untuk siaran (dengan {@link android.app.PendingIntent#getBroadcast getBroadcast()}) dan menyampaikannya ke layanan dalam {@link android.content.Intent} yang memulai layanan. Layanan kemudian bisa menggunakan siaran untuk menyampaikan hasil.
Beberapa permintaan untuk memulai layanan menghasilkan beberapa panggilan pula ke {@link android.app.Service#onStartCommand onStartCommand()} layanan. Akan tetapi, hanya satu permintaan untuk menghentikan layanan (dengan {@link android.app.Service#stopSelf stopSelf()} atau {@link android.content.Context#stopService stopService()}) dibutuhkan untuk menghentikannya.
Layanan yang sudah dimulai harus mengelola daur hidupnya sendiri. Artinya, sistem tidak menghentikan atau memusnahkan layanan kecuali jika harus memulihkan memori sistem dan layanan terus berjalan setelah {@link android.app.Service#onStartCommand onStartCommand()} kembali. Jadi, layanan tersebut harus berhenti sendiri dengan memanggil {@link android.app.Service#stopSelf stopSelf()} atau komponen lain bisa menghentikannya dengan memanggil {@link android.content.Context#stopService stopService()}.
Setelah diminta untuk berhenti dengan {@link android.app.Service#stopSelf stopSelf()} atau {@link android.content.Context#stopService stopService()}, sistem akan menghapus layanan secepatnya.
Akan tetapi, bila layanan Anda menangani beberapa permintaan ke {@link
android.app.Service#onStartCommand onStartCommand()} sekaligus, Anda tidak boleh menghentikan
layanan bila Anda baru selesai memproses permintaan memulai, karena setelah itu mungkin Anda sudah menerima permintaan memulai
yang baru (berhenti pada permintaan pertama akan menghentikan permintaan kedua). Untuk menghindari
masalah ini, Anda bisa menggunakan {@link android.app.Service#stopSelf(int)} untuk memastikan bahwa permintaan
Anda untuk menghentikan layanan selalu berdasarkan pada permintaan memulai terbaru. Artinya, bila Anda memanggil {@link
android.app.Service#stopSelf(int)}, Anda akan meneruskan ID permintaan memulai (startId
yang disampaikan ke {@link android.app.Service#onStartCommand onStartCommand()}) yang terkait dengan permintaan berhenti
Anda. Kemudian jika layanan menerima permintaan memulai baru sebelum Anda bisa memanggil {@link
android.app.Service#stopSelf(int)}, maka ID tidak akan sesuai dan layanan tidak akan berhenti.
Perhatian: Aplikasi Anda perlu menghentikan layanannya bila selesai bekerja untuk menghindari pemborosan sumber daya sistem dan tenaga baterai. Jika perlu, komponen lain bisa menghentikan layanan secara eksplisit dengan memanggil {@link android.content.Context#stopService stopService()}. Bahkan jika Anda mengaktifkan pengikatan bagi layanan, Anda harus selalu menghentikan layanan sendiri jika layanan tersebut menerima panggilan ke {@link android.app.Service#onStartCommand onStartCommand()}.
Untuk informasi selengkapnya tentang daur hidup layanan, lihat bagian di bawah ini tentang Mengelola Daur Hidup Layanan.
Layanan terikat adalah layanan yang memungkinkan komponen aplikasi untuk mengikatnya dengan memanggil {@link android.content.Context#bindService bindService()} guna membuat koneksi yang berlangsung lama (dan umumnya tidak mengizinkan komponen untuk memulainya dengan memanggil {@link android.content.Context#startService startService()}).
Anda sebaiknya membuat layanan terikat bila ingin berinteraksi dengan layanan dari aktivitas dan komponen lain dalam aplikasi Anda atau mengeskpos sebagian fungsionalitas aplikasi Anda ke ke aplikasi lain, melalui komunikasi antarproses (IPC).
Untuk membuat layanan terikat, Anda harus mengimplementasikan metode callback {@link android.app.Service#onBind onBind()} untuk mengembalikan {@link android.os.IBinder} yang mendefinisikan antarmuka bagi komunikasi dengan layanan. Komponen aplikasi lain kemudian bisa memanggil {@link android.content.Context#bindService bindService()} untuk mengambil antarmuka dan mulai memanggil metode pada layanan. Layanan hanya hidup untuk melayani komponen aplikasi yang terikat padanya, jadi bila tidak ada komponen yang terikat pada layanan, sistem akan memusnahkannya (Anda tidak perlu menghentikan layanan terikat seperti halnya bila layanan dimulai melalui {@link android.app.Service#onStartCommand onStartCommand()}).
Untuk membuat layanan terikat, hal yang perlu dilakukan pertama kali adalah mendefinisikan antarmuka yang menetapkan cara klien berkomunikasi dengan layanan. Antarmuka antara layanan dan klien ini harus berupa implementasi {@link android.os.IBinder} dan yang harus dikembalikan layanan Anda dari metode callback {@link android.app.Service#onBind onBind()}. Setelah menerima {@link android.os.IBinder}, klien bisa mulai berinteraksi dengan layanan melalui antarmuka tersebut.
Beberapa klien bisa mengikat ke layanan sekaligus. Bila klien selesai berinteraksi dengan layanan, klien akan memanggil {@link android.content.Context#unbindService unbindService()} untuk melepas ikatan. Bila tidak ada klien yang terikat pada layanan, sistem akan menghapus layanan tersebut.
Ada beberapa cara untuk mengimplementasikan layanan terikat dan implementasinya lebih rumit daripada layanan yang sudah dimulai, jadi layanan terikat dibahas dalam dokumen terpisah tentang Layanan Terikat.
Setelah berjalan, layanan bisa memberi tahu pengguna tentang suatu kejadian menggunakan Pemberitahuan Toast atau Pemberitahuan Baris Status.
Pemberitahuan Toast adalah pesan yang muncul sebentar pada permukaan jendela saat ini kemudian menghilang, sementara pemberitahuan baris status memberikan ikon di baris status dengan pesan yang bisa dipilih oleh pengguna untuk melakukan suatu tindakan (misalnya memulai suatu aktivitas).
Biasanya, pemberitahuan baris status adalah teknik terbaik bila ada pekerjaan latar belakang yang sudah selesai (misalnya file selesai diunduh) dan pengguna kini bisa menggunakannya. Bila pengguna memilih pemberitahuan dari tampilan diperluas, pemberitahuan akan bisa memulai aktivitas (misalnya menampilkan file yang baru diunduh).
Lihat panduan pengembang Pemberitahuan Toast atau Pemberitahuan Baris Status untuk informasi selengkapnya.
Layanan latar depan adalah layanan yang dianggap sebagai sesuatu yang diketahui secara aktif oleh pengguna, jadi bukan sesuatu yang akan dihapus oleh sistem bila memori menipis. Sebuah layanan latar depan harus memberikan pemberitahuan bagi baris status, yang ditempatkan pada heading "Ongoing" yang artinya pemberitahuan tersebut tidak bisa diabaikan kecuali jika layanan dihentikan atau dihapus dari latar depan.
Misalnya, pemutar musik yang memutar musik dari suatu layanan harus diatur untuk berjalan di latar depan, karena pengguna mengetahui operasi tersebut secara eksplisit. Pemberitahuan di baris status bisa menunjukkan lagu saat ini dan memungkinkan pengguna untuk menjalankan suatu aktivitas untuk berinteraksi dengan pemutar musik.
Untuk meminta agar layanan Anda berjalan di latar depan, panggil {@link android.app.Service#startForeground startForeground()}. Metode ini memerlukan dua parameter: sebuah integer yang mengidentifikasi pemberitahuan secara unik dan {@link android.app.Notification} untuk baris status. Misalnya:
Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),
System.currentTimeMillis());
Intent notificationIntent = new Intent(this, ExampleActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(this, getText(R.string.notification_title),
getText(R.string.notification_message), pendingIntent);
startForeground(ONGOING_NOTIFICATION_ID, notification);
Perhatian: ID integer yang Anda berikan ke {@link android.app.Service#startForeground startForeground()} tidak boleh 0.
Untuk menghapus layanan dari latar depan, panggil {@link android.app.Service#stopForeground stopForeground()}. Metode ini memerlukan boolean, yang menunjukkan apakah pemberitahuan baris status juga akan dihapus. Metode ini tidak menghentikan layanan. Akan tetapi, jika Anda menghentikan layanan saat masih berjalan di latar depan maka pemberitahuan juga akan dihapus.
Untuk informasi selengkapnya tentang pemberitahuan, lihat Membuat Pemberitahuan Baris Status.
Daur hidup layanan jauh lebih sederhana daripada daur hidup aktivitas. Akan tetapi, lebih penting lagi adalah memerhatikan dengan cermat bagaimana layanan Anda dibuat dan dimusnahkan, karena suatu layanan bisa berjalan di latar belakang tanpa disadari oleh pengguna.
Daur hidup layanan—dari saat dibuat hingga dimusnahkan—bisa mengikuti dua path berbeda:
Layanan dibuat bila komponen lain memanggil {@link android.content.Context#startService startService()}. Layanan kemudian berjalan terus-menerus dan harus berhenti sendiri dengan memanggil {@link android.app.Service#stopSelf() stopSelf()}. Komponen lain juga bisa menghentikan layanan dengan memanggil {@link android.content.Context#stopService stopService()}. Bila layanan dihentikan, sistem akan menghancurkannya.
Layanan dibuat bila komponen lain (klien) memanggil {@link android.content.Context#bindService bindService()}. Klien kemudian berkomunikasi dengan layanan melalui antarmuka {@link android.os.IBinder}. Klien bisa menutup koneksi dengan memanggil {@link android.content.Context#unbindService unbindService()}. Sejumlah klien bisa mengikat pada layanan yang sama dan bila semuanya melepas ikatan, sistem akan memusnahkan layanan tersebut. (Layanan tidak perlu berhenti sendiri.)
Kedua path tersebut tidak benar-benar terpisah. Artinya, Anda bisa mengikat ke layanan yang sudah dimulai dengan {@link android.content.Context#startService startService()}. Misalnya, layanan musik latar belakang bisa dimulai dengan memanggil {@link android.content.Context#startService startService()} dengan {@link android.content.Intent} yang mengidentifikasi musik yang akan diputar. Kemudian, mungkin saat pengguna ingin mengontrol pemutar musik atau mendapatkan informasi tentang lagu yang diputar, aktivitas bisa mengikat ke layanan dengan memanggil {@link android.content.Context#bindService bindService()}. Dalam kasus seperti ini, {@link android.content.Context#stopService stopService()} atau {@link android.app.Service#stopSelf stopSelf()} tidak menghentikan layanan sampai semua klien melepas ikatan.
Seperti halnya aktivitas, layanan memiliki metode callback daur hidup yang bisa Anda implementasikan untuk memantau perubahan status layanan dan melakukan pekerjaan pada waktu yang tepat. Layanan skeleton berikut memperagakan setiap metode daur hidup:
public class ExampleService extends Service {
int mStartMode; // indicates how to behave if the service is killed
IBinder mBinder; // interface for clients that bind
boolean mAllowRebind; // indicates whether onRebind should be used
@Override
public void {@link android.app.Service#onCreate onCreate}() {
// The service is being created
}
@Override
public int {@link android.app.Service#onStartCommand onStartCommand}(Intent intent, int flags, int startId) {
// The service is starting, due to a call to {@link android.content.Context#startService startService()}
return mStartMode;
}
@Override
public IBinder {@link android.app.Service#onBind onBind}(Intent intent) {
// A client is binding to the service with {@link android.content.Context#bindService bindService()}
return mBinder;
}
@Override
public boolean {@link android.app.Service#onUnbind onUnbind}(Intent intent) {
// All clients have unbound with {@link android.content.Context#unbindService unbindService()}
return mAllowRebind;
}
@Override
public void {@link android.app.Service#onRebind onRebind}(Intent intent) {
// A client is binding to the service with {@link android.content.Context#bindService bindService()},
// after onUnbind() has already been called
}
@Override
public void {@link android.app.Service#onDestroy onDestroy}() {
// The service is no longer used and is being destroyed
}
}
Catatan: Tidak seperti metode callback daur hidup aktivitas, Anda tidak perlu memanggil implementasi superkelas metode callback tersebut.
Gambar 2. Daur hidup layanan. Diagram di sebelah kiri menampilkan daur hidup bila layanan dibuat dengan {@link android.content.Context#startService startService()} dan diagram di sebelah kanan menampilkan daur hidup bila layanan dibuat dengan {@link android.content.Context#bindService bindService()}.
Dengan mengimplementasikan metode-metode ini, Anda bisa memantau dua loop tersarang (nested loop) daur hidup layanan:
Metode {@link android.app.Service#onCreate onCreate()} dan {@link android.app.Service#onDestroy onDestroy()} diperlukan semua layanan, baik yang dibuat oleh {@link android.content.Context#startService startService()} maupun {@link android.content.Context#bindService bindService()}.
Jika layanan telah dimulai, masa pakai aktif akan berakhir pada saat yang sama dengan berakhirnya seluruh masa pakai (layanan masih aktif bahkan setelah {@link android.app.Service#onStartCommand onStartCommand()} kembali). Jika layanan tersebut terikat, masa pakai aktifnya akan berakhir bila {@link android.app.Service#onUnbind onUnbind()} kembali.
Catatan: Meskipun layanan yang sudah dimulai dihentikan dengan panggilan ke {@link android.app.Service#stopSelf stopSelf()} atau {@link android.content.Context#stopService stopService()}, tidak ada callback tersendiri bagi layanan tersebut (tidak ada callback {@code onStop()}). Jadi, kecuali jika layanan terikat ke klien, sistem akan memusnahkannya bila layanan dihentikan—{@link android.app.Service#onDestroy onDestroy()} adalah satu-satunya callback yang diterima.
Gambar 2 mengilustrasikan metode callback yang lazim bagi suatu layanan. Walaupun gambar tersebut memisahkan layanan yang dibuat oleh {@link android.content.Context#startService startService()} dari layanan yang dibuat oleh {@link android.content.Context#bindService bindService()}, ingatlah bahwa suatu layanan, bagaimana pun dimulainya, bisa memungkinkan klien mengikat padanya. Jadi, suatu layanan yang awalnya dimulai dengan {@link android.app.Service#onStartCommand onStartCommand()} (oleh klien yang memanggil {@link android.content.Context#startService startService()}) masih bisa menerima panggilan ke {@link android.app.Service#onBind onBind()} (bila klien memanggil {@link android.content.Context#bindService bindService()}).
Untuk informasi selengkapnya tentang membuat layanan yang menyediakan pengikatan, lihat dokumen Layanan Terikat, yang menyertakan informasi selengkapnya tentang metode callback {@link android.app.Service#onRebind onRebind()} di bagian tentang Mengelola Daur Hidup Layanan Terikat.