Foreground Services

The Problem with Background Work

Android aggressively restricts background execution to preserve battery life. Apps cannot run long-running operations in the background after the user leaves the app. A foreground service solves this by elevating the process priority and showing a persistent notification.

When a Foreground Service Is Required

Use a foreground service when the user must be aware the app is doing work and the work cannot be interrupted:

• Music playback — playing audio while the app is in the background
• GPS tracking — recording location during navigation or fitness tracking
• File downloads — large downloads that must complete without interruption
• Data synchronization — ongoing sync with a server
• Phone calls — VoIP apps maintaining a connection

When NOT to Use a Foreground Service

• Periodic data refresh — use WorkManager instead
• One-shot network calls — use coroutines with WorkManager
• Short processing — WorkManager or JobIntentService

Android Version Restrictions

// Android 12+: Check if you can start a foreground service
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    val am = getSystemService<ActivityManager>()
    if (!am?.isForegroundServiceLaunchAllowed) {
        // Show explanation or use WorkManager instead
        return
    }
}

Foreground Service vs WorkManager

Service Declaration

Register the service in AndroidManifest.xml. For Android 9+, declare the foreground service type.

<service
    android:name=".MusicService"
    android:foregroundServiceType="mediaPlayback"
    android:exported="false" />

Service Implementation

A foreground service must call startForeground() with a notification within 5 seconds of being started, or the system kills the process.

class MusicService : Service() {

    private val binder = MusicBinder()
    private var mediaPlayer: MediaPlayer? = null

    inner class MusicBinder : Binder() {
        fun getService(): MusicService = this@MusicService
    }

    override fun onBind(intent: Intent): IBinder = binder

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        when (intent?.action) {
            ACTION_PLAY -> play(intent.getStringExtra(EXTRA_TRACK_URL))
            ACTION_PAUSE -> pause()
            ACTION_STOP -> stopSelf()
        }
        return START_STICKY  // restart if killed by system
    }

    private fun play(url: String?) {
        url?.let {
            mediaPlayer = MediaPlayer().apply {
                setDataSource(it)
                prepare()
                start()
            }
            startForeground(NOTIFICATION_ID, buildNotification("Playing"))
        }
    }

    private fun pause() {
        mediaPlayer?.pause()
        updateNotification("Paused")
    }

    override fun onDestroy() {
        mediaPlayer?.release()
        mediaPlayer = null
        super.onDestroy()
    }

    private fun buildNotification(text: String): Notification {
        val intent = Intent(this, MainActivity::class.java)
        val pending = PendingIntent.getActivity(
            this, 0, intent, PendingIntent.FLAG_IMMUTABLE
        )

        return NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle("Music Player")
            .setContentText(text)
            .setSmallIcon(R.drawable.ic_music)
            .setContentIntent(pending)
            .build()
    }

    companion object {
        const val NOTIFICATION_ID = 1
        const val CHANNEL_ID = "music_channel"
        const val ACTION_PLAY = "com.example.PLAY"
        const val ACTION_PAUSE = "com.example.PAUSE"
        const val ACTION_STOP = "com.example.STOP"
        const val EXTRA_TRACK_URL = "track_url"
    }
}

Starting the Service

// Start from an Activity or Fragment
val intent = Intent(this, MusicService::class.java).apply {
    action = MusicService.ACTION_PLAY
    putExtra(MusicService.EXTRA_TRACK_URL, trackUrl)
}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    startForegroundService(intent)
} else {
    startService(intent)
}

Service Lifecycle

1. Created — onCreate() called once when service is first created
2. Started — onStartCommand() called each time startService() is invoked
3. Bound — onBind() called when a client binds via bindService()
4. Destroyed — onDestroy() called when service is stopped

Notification Channels

Android 8.0+ requires a notification channel for foreground service notifications:

fun createNotificationChannel() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(
            CHANNEL_ID,
            "Music Playback",
            NotificationManager.IMPORTANCE_LOW
        )
        getSystemService(NotificationManager::class.java)
            .createNotificationChannel(channel)
    }
}

Use IMPORTANCE_LOW so the notification does not make sound or appear on the lock screen — it is just a persistent indicator.