Handling Background Execution Limits Correctly

// Check the app's standby bucket
fun checkStandbyBucket(context: Context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        val usageStatsManager =
            context.getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager
        val bucket = usageStatsManager.appStandbyBucket
 
        val bucketName = when (bucket) {
            UsageStatsManager.STANDBY_BUCKET_ACTIVE -> "ACTIVE"
            UsageStatsManager.STANDBY_BUCKET_WORKING_SET -> "WORKING_SET"
            UsageStatsManager.STANDBY_BUCKET_FREQUENT -> "FREQUENT"
            UsageStatsManager.STANDBY_BUCKET_RARE -> "RARE"
            UsageStatsManager.STANDBY_BUCKET_RESTRICTED -> "RESTRICTED"
            else -> "UNKNOWN ($bucket)"
        }
 
        Log.d("Standby", "Current bucket: $bucketName")
    }
}

class DataSyncWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {
 
    override suspend fun doWork(): Result {
        return try {
            val syncResult = SyncEngine.sync()
            if (syncResult.hasMore) {
                // Schedule immediate follow-up for remaining data
                Result.success(workDataOf("continuation" to true))
            } else {
                Result.success()
            }
        } catch (e: IOException) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
 
    companion object {
        fun schedulePeriodicSync(context: Context) {
            val constraints = Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresBatteryNotLow(true)
                .build()
 
            val syncRequest = PeriodicWorkRequestBuilder<DataSyncWorker>(
                1, TimeUnit.HOURS,
                15, TimeUnit.MINUTES // flex period
            )
                .setConstraints(constraints)
                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 10, TimeUnit.MINUTES)
                .addTag("periodic_sync")
                .build()
 
            WorkManager.getInstance(context).enqueueUniquePeriodicWork(
                "data_sync",
                ExistingPeriodicWorkPolicy.UPDATE,
                syncRequest
            )
        }
 
        fun scheduleOneTimeSync(context: Context, urgent: Boolean = false) {
            val request = OneTimeWorkRequestBuilder<DataSyncWorker>()
                .setConstraints(
                    Constraints.Builder()
                        .setRequiredNetworkType(NetworkType.CONNECTED)
                        .build()
                )
                .apply {
                    if (urgent) setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
                }
                .build()
 
            WorkManager.getInstance(context).enqueueUniqueWork(
                "one_time_sync",
                ExistingWorkPolicy.REPLACE,
                request
            )
        }
    }
}

// Option 1: Start from a user-visible context (Activity)
class UploadActivity : AppCompatActivity() {
    fun startUpload() {
        val intent = Intent(this, UploadService::class.java)
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            startForegroundService(intent)
        } else {
            startService(intent)
        }
    }
}
 
// Option 2: Use WorkManager with setForeground for long-running work
class UploadWorker(
    context: Context, params: WorkerParameters
) : CoroutineWorker(context, params) {
 
    override suspend fun doWork(): Result {
        setForeground(createForegroundInfo())
        return performUpload()
    }
 
    private fun createForegroundInfo(): ForegroundInfo {
        val notification = NotificationCompat.Builder(applicationContext, "upload")
            .setContentTitle("Uploading")
            .setSmallIcon(R.drawable.ic_upload)
            .setOngoing(true)
            .build()
 
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            ForegroundInfo(
                NOTIFICATION_ID, notification,
                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
            )
        } else {
            ForegroundInfo(NOTIFICATION_ID, notification)
        }
    }
}

<!-- AndroidManifest.xml -->
<service
    android:name=".UploadService"
    android:foregroundServiceType="dataSync"
    android:exported="false" />
 
<service
    android:name=".LocationTrackingService"
    android:foregroundServiceType="location"
    android:exported="false" />

class HighPriorityFcmService : FirebaseMessagingService() {
    override fun onMessageReceived(message: RemoteMessage) {
        // High-priority FCM messages wake the device from Doze
        // Use this for time-sensitive operations only
        if (message.priority == RemoteMessage.PRIORITY_HIGH) {
            val work = OneTimeWorkRequestBuilder<UrgentSyncWorker>()
                .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
                .build()
            WorkManager.getInstance(this).enqueue(work)
        }
    }
}

class ResilientWorker(
    context: Context, params: WorkerParameters
) : CoroutineWorker(context, params) {
 
    override suspend fun doWork(): Result {
        val bucket = getStandbyBucket()
 
        // Adjust work scope based on standby bucket
        val workScope = when (bucket) {
            StandbyBucket.ACTIVE, StandbyBucket.WORKING_SET -> WorkScope.FULL
            StandbyBucket.FREQUENT -> WorkScope.ESSENTIAL
            else -> WorkScope.MINIMAL
        }
 
        return try {
            when (workScope) {
                WorkScope.FULL -> {
                    syncAllData()
                    prefetchContent()
                    uploadAnalytics()
                }
                WorkScope.ESSENTIAL -> {
                    syncAllData()
                    uploadAnalytics()
                }
                WorkScope.MINIMAL -> {
                    syncCriticalDataOnly()
                }
            }
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < maxRetries(workScope)) Result.retry()
            else Result.failure()
        }
    }
 
    private fun maxRetries(scope: WorkScope) = when (scope) {
        WorkScope.FULL -> 3
        WorkScope.ESSENTIAL -> 2
        WorkScope.MINIMAL -> 1
    }
}
 
enum class WorkScope { FULL, ESSENTIAL, MINIMAL }