Background Work: WorkManager, Services and Alarms

// core/data/src/main/kotlin/com/example/trailmate/core/data/TrailSyncWorker.kt
package com.example.trailmate.core.data

import android.content.Context
import androidx.hilt.work.HiltWorker
import androidx.work.CoroutineWorker
import androidx.work.Data
import androidx.work.WorkerParameters
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject

@HiltWorker
class TrailSyncWorker @AssistedInject constructor(
    @Assisted appContext: Context,
    @Assisted workerParams: WorkerParameters,
    private val trailRepository: TrailRepository,
) : CoroutineWorker(appContext, workerParams) {

    override suspend fun doWork(): Result {
        val region = inputData.getString(KEY_REGION)
        return try {
            val syncedCount = trailRepository.refresh(region)
            Result.success(Data.Builder().putInt(KEY_SYNCED_COUNT, syncedCount).build())
        } catch (e: java.io.IOException) {
            // A transient network failure: let WorkManager retry with backoff.
            Result.retry()
        } catch (e: Exception) {
            // Anything else is not worth retrying.
            Result.failure()
        }
    }

    companion object {
        const val KEY_REGION = "region"
        const val KEY_SYNCED_COUNT = "syncedCount"
    }
}

// app/src/main/kotlin/com/example/trailmate/TrailMateApplication.kt
package com.example.trailmate

import android.app.Application
import androidx.hilt.work.HiltWorkerFactory
import androidx.work.Configuration
import dagger.hilt.android.HiltAndroidApp
import javax.inject.Inject

@HiltAndroidApp
class TrailMateApplication : Application(), Configuration.Provider {

    @Inject lateinit var workerFactory: HiltWorkerFactory

    override val workManagerConfiguration: Configuration
        get() = Configuration.Builder().setWorkerFactory(workerFactory).build()
}

<!-- app/src/main/AndroidManifest.xml: disable WorkManager's default initializer.
     The root <manifest> element declares xmlns:tools="http://schemas.android.com/tools". -->
<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="androidx.work.WorkManagerInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
</provider>

val syncConstraints = androidx.work.Constraints.Builder()
    .setRequiredNetworkType(androidx.work.NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .setRequiresStorageNotLow(true)
    .build()

// A one-time sync, e.g. triggered right after the user pulls-to-refresh.
val oneTimeSync = androidx.work.OneTimeWorkRequestBuilder<TrailSyncWorker>()
    .setConstraints(syncConstraints)
    .setInputData(androidx.work.workDataOf(TrailSyncWorker.KEY_REGION to "pacific-northwest"))
    .build()

androidx.work.WorkManager.getInstance(context).enqueue(oneTimeSync)

// A background refresh every 6 hours, regardless of whether the app is open.
val periodicSync = androidx.work.PeriodicWorkRequestBuilder<TrailSyncWorker>(6, java.util.concurrent.TimeUnit.HOURS)
    .setConstraints(syncConstraints)
    .setBackoffCriteria(
        androidx.work.BackoffPolicy.EXPONENTIAL,
        androidx.work.WorkRequest.MIN_BACKOFF_MILLIS,
        java.util.concurrent.TimeUnit.MILLISECONDS,
    )
    .build()

androidx.work.WorkManager.getInstance(context)
    .enqueueUniquePeriodicWork(
        "trail-sync",
        androidx.work.ExistingPeriodicWorkPolicy.KEEP,
        periodicSync,
    )

val downloadPhotosWork = androidx.work.OneTimeWorkRequestBuilder<DownloadQueuedPhotosWorker>().build()
val compressPhotosWork = androidx.work.OneTimeWorkRequestBuilder<CompressPhotosWorker>().build()
val uploadPhotosWork = androidx.work.OneTimeWorkRequestBuilder<UploadPhotosWorker>()
    .setConstraints(androidx.work.Constraints.Builder().setRequiredNetworkType(androidx.work.NetworkType.UNMETERED).build())
    .build()

androidx.work.WorkManager.getInstance(context)
    .beginWith(downloadPhotosWork)
    .then(compressPhotosWork)
    .then(uploadPhotosWork)
    .enqueue()

val uploadPhotoNow = androidx.work.OneTimeWorkRequestBuilder<UploadPhotoWorker>()
    .setExpedited(androidx.work.OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .setInputData(androidx.work.workDataOf("photoUri" to photoUri.toString()))
    .build()

// feature/settings/src/main/kotlin/com/example/trailmate/feature/settings/SettingsViewModel.kt
package com.example.trailmate.feature.settings

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.work.WorkInfo
import androidx.work.WorkManager
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import javax.inject.Inject
import dagger.hilt.android.lifecycle.HiltViewModel

@HiltViewModel
class SettingsViewModel @Inject constructor(
    workManager: WorkManager,
) : ViewModel() {

    val syncState: StateFlow<WorkInfo.State?> =
        workManager.getWorkInfosForUniqueWorkFlow("trail-sync")
            .map { infos -> infos.firstOrNull()?.state }
            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
}

// core/data/src/test/kotlin/com/example/trailmate/core/data/TrailSyncWorkerTest.kt
package com.example.trailmate.core.data

import androidx.test.core.app.ApplicationProvider
import androidx.work.ListenableWorker.Result
import androidx.work.testing.TestListenableWorkerBuilder
import androidx.work.workDataOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner

@RunWith(RobolectricTestRunner::class)
class TrailSyncWorkerTest {

    @Test
    fun `doWork returns success when repository refresh succeeds`() = runTest {
        val worker = TestListenableWorkerBuilder<TrailSyncWorker>(
            context = ApplicationProvider.getApplicationContext(),
            inputData = workDataOf(TrailSyncWorker.KEY_REGION to "pacific-northwest"),
        ).setWorkerFactory(FakeTrailSyncWorkerFactory(FakeTrailRepository()))
            .build()

        val result = worker.doWork()

        assert(result is Result.Success)
    }
}

<!-- app/src/main/AndroidManifest.xml -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<service
    android:name=".RecordHikeService"
    android:foregroundServiceType="location"
    android:exported="false" />

// feature/trails/src/main/kotlin/com/example/trailmate/feature/trails/RecordHikeService.kt
package com.example.trailmate.feature.trails

import android.app.Service
import android.content.Intent
import android.content.pm.ServiceInfo
import android.os.Build
import android.os.IBinder
import androidx.core.app.NotificationCompat
import androidx.core.app.ServiceCompat
import com.example.trailmate.R
import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationCallback
import com.google.android.gms.location.LocationRequest
import com.google.android.gms.location.LocationResult
import com.google.android.gms.location.LocationServices
import com.example.trailmate.core.data.HikeSessionRepository
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch
import javax.inject.Inject

@AndroidEntryPoint
class RecordHikeService : Service() {

    @Inject lateinit var hikeSessionRepository: HikeSessionRepository

    private val serviceScope = CoroutineScope(SupervisorJob())
    private lateinit var fusedLocationClient: FusedLocationProviderClient
    private lateinit var locationCallback: LocationCallback

    override fun onCreate() {
        super.onCreate()
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
        locationCallback = object : LocationCallback() {
            override fun onLocationResult(result: LocationResult) {
                result.lastLocation?.let { location ->
                    serviceScope.launch { hikeSessionRepository.recordPoint(location) }
                }
            }
        }
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
            .setContentTitle(getString(R.string.recording_hike))
            .setContentText(getString(R.string.tap_to_view_progress))
            .setSmallIcon(R.drawable.ic_hike)
            .setOngoing(true)
            .build()

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            ServiceCompat.startForeground(
                this,
                NOTIFICATION_ID,
                notification,
                ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION,
            )
        } else {
            startForeground(NOTIFICATION_ID, notification)
        }

        val locationRequest = LocationRequest.Builder(LOCATION_INTERVAL_MS).build()
        fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, mainLooper)

        // START_STICKY: if the system kills this process under memory pressure, recreate the
        // service (with a null intent) once resources free up, rather than dropping the session.
        return START_STICKY
    }

    override fun onDestroy() {
        fusedLocationClient.removeLocationUpdates(locationCallback)
        serviceScope.cancel()
        super.onDestroy()
    }

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

    companion object {
        const val CHANNEL_ID = "trail_updates"
        private const val NOTIFICATION_ID = 42
        private const val LOCATION_INTERVAL_MS = 5_000L
    }
}