How to Create a Background Service in Android

Background services allow Android applications to perform work without a user interface — such as syncing data, processing uploads/downloads, or monitoring sensors even when the app is not in the foreground. Modern Android (API 26+) enforces strict rules on background execution to optimize battery life and performance.

This updated guide on javatechig.com walks you through background services, foreground alternatives, lifecycle considerations, and best practices using both Kotlin and Java.

What Is a Background Service?

A background service runs tasks when the user is not actively interacting with the app. Traditional services executed indefinitely, but modern versions of Android increasingly restrict background execution to conserve system resources.

Key use cases include:

• Data synchronization
• Notifications
• Periodic tasks
• Sensor or location scans

In Android 8+ (API 26+), services started in the background must transition to foreground or be scheduled via modern APIs like WorkManager.

Background Service Lifecycle

Services transition through states:

• onCreate() — Initialize resources
• onStartCommand() — Service starts work
• onDestroy() — Cleanup before termination

Android may kill background services when under memory pressure unless converted to a foreground service or scheduled using modern frameworks.

Simple Background Service Example

Kotlin

class MyBackgroundService : Service() {
    override fun onBind(intent: Intent?): IBinder? = null

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Thread {
            // Background work here
            Log.d("Service", "Running in background")
        }.start()

        return START_NOT_STICKY
    }
}

Java

public class MyBackgroundService extends Service {
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(() -> {
            // Background work here
            Log.d("Service", "Running in background");
        }).start();

        return START_NOT_STICKY;
    }
}

Add the Service to AndroidManifest

<service
    android:name=".MyBackgroundService"
    android:exported="false" />

This declaration allows Android to recognize and start your service.

Starting and Stopping the Service

Start Service

startService(Intent(this, MyBackgroundService::class.java))

Stop Service

stopService(Intent(this, MyBackgroundService::class.java))

Use these calls when required (e.g., from an Activity or BroadcastReceiver).

Why Modern Android Limits Background Services

To improve battery life and UX, Android restricts long‑running background services. If your service remains active while the user is not interacting, Android may:

• Kill the service
• Delay execution
• Require a foreground service with notification

Foreground Service Alternative

For persistent tasks, use a foreground service — one that shows a persistent notification.

Kotlin Example

val notification = NotificationCompat.Builder(this, "channel")
    .setContentTitle("Service Running")
    .setContentText("Performing task")
    .setSmallIcon(R.drawable.ic_notification)
    .build()

startForeground(1001, notification)

This ensures the system treats your service as priority work.

Using WorkManager (Recommended for Background Jobs)

For most background work (sync, periodic tasks), Android recommends WorkManager.

Kotlin Example

val uploadWork = OneTimeWorkRequestBuilder<MyWorker>()
    .build()

WorkManager.getInstance(context).enqueue(uploadWork)

WorkManager runs efficiently across Android versions and respects OS restrictions.

Best Practices for Background Tasks

Choose the Right API

Handling Battery & Doze Mode

Android may defer background execution under Doze/Standby. Use:

• WorkManager constraints (e.g., network required)
• AlarmManager for precise schedules (use sparingly)
• Avoid unnecessary wake locks

Common Errors & Fixes

Service Killed Immediately

Cause: Service started in background without foreground flag
Fix: Convert to foreground or schedule via WorkManager

ANR (App Not Responding)

Cause: Heavy work on the main thread
Fix: Always offload work to a thread or WorkManager

Missing Notification

Cause: Foreground requirement on API 26+
Fix: Create a NotificationChannel and show a notification

Summary

Background execution on Android has evolved due to performance optimization. While traditional background services still exist, modern Android requires:

• Foreground services for persistent work
• WorkManager for deferred/scheduled tasks
• Proper lifecycle and system awareness

Use these best practices to build efficient, compliance‑ready background operations in your Android apps.