Background Service — apa itu, jenis dan cara kerjanya di Android

Apa itu Background Service di Android?

Background Service (atau sederhananya Service) — adalah salah satu dari empat komponen utama aplikasi Android bersama dengan Activity, BroadcastReceiver dan ContentProvider. Tidak seperti Activity, Service tidak memiliki antarmuka visual dan dirancang untuk melakukan operasi yang harus berlanjut terlepas dari apakah aplikasi berada di latar depan atau tidak.

Service bekerja di thread utama (main thread) aplikasi, oleh karena itu setiap operasi pemblokiran di dalamnya memerlukan pembuatan thread terpisah. Jika tidak dilakukan, sistem akan memanggil ANR (Application Not Responding). Untuk operasi latar belakang sederhana, Android menyediakan IntentService yang secara otomatis membuat thread kerja. Dalam proyek modern, disarankan menggunakan Kotlin-coroutine dengan CoroutineScope di dalam Service untuk pemrosesan asinkron tanpa memblokir thread utama.

Tujuan utama Service — memutar musik, mengunduh file, bekerja dengan permintaan jaringan, sinkronisasi data dan tugas-tugas lain yang harus berlanjut setelah pengguna meninggalkan aplikasi. Namun dengan dirilisnya Android 8, pengembang harus memilih jenis layanan secara sadar, dengan mempertimbangkan batasan kerja di latar belakang.

Bagaimana siklus hidup Service bekerja?

Service memiliki siklus hidup sendiri yang berbeda dari Activity. Ini mencakup empat metode kunci: onCreate, onStartCommand, onBind dan onDestroy. Memahami siklus ini diperlukan untuk implementasi tugas latar belakang yang benar tanpa kebocoran memori.

onCreate dan onStartCommand

Metode onCreate dipanggil saat pembuatan layanan, sekali selama masa hidupnya. Di dalamnya sumber daya diinisialisasi: timer, koneksi database, soket. Metode onStartCommand dipanggil setiap kali startService dipanggil, yang memungkinkan pengiriman perintah ke layanan yang sudah berjalan. Nilai yang dikembalikan menentukan perilaku sistem saat restart.

class DownloadService : Service() {

    override fun onCreate() {
        super.onCreate()
        initializeDownloader()
    }

    override fun onStartCommand(
        intent: Intent?,
        flags: Int,
        startId: Int
    ): Int {
        downloadFile(intent?.getStringExtra("url"))
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? = null
}

onBind dan onDestroy

onBind dipanggil saat mengikat layanan melalui bindService dan mengembalikan objek IBinder untuk interaksi dengan klien. Metode ini hanya digunakan untuk Bound Service. onDestroy — panggilan terakhir sebelum penghancuran layanan. Di dalamnya semua sumber daya dibebaskan, thread dihentikan dan tugas dibatalkan.

Jenis layanan latar belakang

Android menawarkan tiga jenis Service, masing-masing dirancang untuk skenarionya sendiri. Memilih jenis yang salah dapat menyebabkan aplikasi tidak stabil atau konsumsi baterai berlebihan.

Started Service

Started Service dijalankan dengan memanggil startService dan bekerja sampai stopSelf atau stopService dipanggil. Cocok untuk tugas yang harus segera dilakukan: mengirim analytics, memproses gambar, mengunduh satu file. Setelah selesai, layanan berhenti sendiri.

Bound Service

Bound Service menyediakan antarmuka klien-server, memungkinkan Activity, Fragment atau komponen lain untuk berinteraksi dengan layanan. Layanan hidup selama ada setidaknya satu klien yang terikat. Ketika semua klien terlepas, layanan dihancurkan. Bound Service nyaman untuk tugas yang memerlukan komunikasi dua arah: pemutar musik, navigasi.

Foreground Service

Foreground Service — adalah Started Service dengan notifikasi permanen di bilah status. Sistem menganggap layanan seperti itu aktif dan tidak membunuhnya bahkan saat memori tidak mencukupi. Foreground Service wajib untuk memutar musik, merekam audio, melacak lokasi dan tugas-tugas lain yang penting bagi pengguna.

Membuat dan menjalankan Service

Membuat layanan dimulai dengan mendeklarasikan kelas yang mewarisi Service dan mendaftarkannya di AndroidManifest.xml. Tanpa pendaftaran di manifes, sistem tidak akan dapat menjalankan layanan, dan setiap panggilan startService akan menyebabkan pengecualian.

// Pendaftaran di AndroidManifest.xml
@SuppressLint("ForegroundServiceType")
class SyncService : Service() {

    override fun onStartCommand(
        intent: Intent?,
        flags: Int,
        startId: Int
    ): Int {
        startForeground(
            NOTIFICATION_ID,
            createNotification()
        )
        performSync(intent)
        return START_NOT_STICKY
    }
}

Untuk menjalankan layanan dari Activity atau Fragment digunakan Intent dengan penyebutan kelas layanan secara eksplisit. Mulai Android 8, untuk Foreground Service diperlukan izin FOREGROUND_SERVICE di manifes.

// Menjalankan Started Service
val intent = Intent(this, SyncService::class.java)
intent.putExtra("action", "sync")
startService(intent)

// Menjalankan Foreground Service (Android 8+)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    startForegroundService(intent)
} else {
    startService(intent)
}

Batasan di Android 8+

Mulai Android 8 (API 26) Google memberlakukan batasan ketat pada layanan latar belakang. Menjalankan Service di latar belakang (saat aplikasi tidak di latar depan) hanya diizinkan dalam kasus luar biasa: saat menerima notifikasi push, setelah perangkat boot, atau melalui JobScheduler.

Untuk tugas jangka panjang yang tidak memerlukan eksekusi segera, disarankan menggunakan WorkManager atau JobScheduler. Jika aplikasi benar-benar membutuhkan layanan yang berjalan, satu-satunya cara adalah Foreground Service dengan notifikasi yang dilihat pengguna. Menjalankan layanan di latar belakang tanpa notifikasi akan diabaikan oleh sistem.

JobIntentService untuk kompatibilitas mundur

JobIntentService — adalah kelas khusus yang muncul di support library untuk bekerja pada Android 5+. Ini menggabungkan perilaku IntentService (thread kerja otomatis, pemrosesan sekuensial) dengan penjadwalan melalui JobScheduler. Di Android 8+ JobIntentService menggunakan JobScheduler di bawah kap, dan pada versi yang lebih lama menggunakan Service biasa. Ini memungkinkan penanganan seragam tugas latar belakang tanpa pemeriksaan versi Android tambahan.

class UploadJobService : JobIntentService() {

    companion object {
        private const val JOB_ID = 1000

        fun enqueueWork(context: Context, work: Intent) {
            enqueueWork(
                context,
                UploadJobService::class.java,
                JOB_ID,
                work
            )
        }
    }

    override fun onHandleWork(intent: Intent) {
        val fileUri = intent.getStringExtra("file_uri")
        // Dieksekusi di thread latar belakang
        uploadFile(fileUri)
    }
}

Manajemen memori dan kebocoran di Service

Salah satu masalah umum saat bekerja dengan Background Service adalah kebocoran memori. Karena Service dapat hidup lebih lama dari Activity, referensi ke Activity di dalam Service (melalui listener, callback atau broadcast) menyebabkan ketidakmampuan pengumpulan sampah untuk komponen UI. Disarankan menggunakan WeakReference, ViewModel atau LiveData untuk komunikasi Service dengan UI. Di onDestroy harus membatalkan semua langganan, menghentikan thread dan menutup kursor.

Service vs WorkManager: kapan memilih apa

Pilihan antara Background Service dan WorkManager tergantung pada skenario. Service cocok untuk tugas yang harus segera dan terus menerus dilakukan: memutar musik, merekam audio, melacak GPS. WorkManager lebih baik untuk tugas yang ditunda dan dijamin: sinkronisasi, mengirim analytics, mengunggah log. WorkManager bertahan dari restart perangkat, sedangkan Service tidak. Service bisa menjadi Foreground dengan notifikasi, sementara WorkManager bekerja diam di latar belakang. Dalam praktiknya, pengembang menggabungkan kedua pendekatan: Foreground Service untuk tugas kritis pengguna dan WorkManager untuk pemeliharaan latar belakang.

Android 12 memperkenalkan bendera android:foregroundServiceType yang mengharuskan menentukan jenis layanan: dataSync, camera, connectedDevice, location, mediaPlayback dan lainnya. Penentuan jenis yang salah menyebabkan pengecualian saat startup. Praktik ini membuat Background Service lebih transparan bagi pengguna dan sistem.

Contoh pendaftaran Service di AndroidManifest

Pendaftaran Service yang benar di manifes mencakup atribut exported (aksesibilitas untuk aplikasi eksternal), foregroundServiceType (jenis layanan latar belakang di Android 12+) dan permission. Untuk Bound Service juga perlu mendeklarasikan android:permission="android.permission.BIND_JOB_SERVICE" untuk JobIntentService. Tanpa pendaftaran di manifes, setiap panggilan startService atau bindService akan berakhir dengan pengecualian, oleh karena itu pemeriksaan manifes adalah langkah pertama dalam mendiagnosis masalah dengan Service.