Android Studio中应用关闭时如何完成长耗时任务？

Hey there! Let's break down the best, most reliable ways to handle this task in Android—since you're new to the ecosystem, I'll keep things clear and actionable, and tie it back to your Swift experience too.

First, let's address why onStop() isn't working: Android's system is aggressive about reclaiming memory, so when your app is marked for termination, it won't wait around for your network calls to finish. Unlike Swift's applicationWillTerminate() with a delay (which can be hit-or-miss even there), Android has built-in tools designed specifically for guaranteed background tasks.

The Most Elegant & Reliable Solution: WorkManager #

Google built WorkManager exactly for scenarios like this—tasks you need to complete even if the app is closed or the device restarts. It automatically handles background restrictions across all Android versions (API 14+) and uses the most appropriate underlying mechanism (JobScheduler, AlarmManager, etc.) based on the device's OS.

Here's how to implement it step by step:

1. Add the WorkManager Dependency

In your app-level build.gradle (Module level):

dependencies {
    implementation "androidx.work:work-runtime:2.8.1"
}

2. Create a Worker Class for Your Task

This is where you'll put your API fetch and POST logic. WorkManager runs this code on a background thread automatically, so no need to handle threading yourself.

class SyncUserParamsWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
    override fun doWork(): Result {
        return try {
            // 1. Fetch real-time params from your API
            val inputStream = URL("https://your-api-endpoint.com/current-params").openStream()
            val params = BufferedReader(InputStreamReader(inputStream)).use { it.readText() }
            
            // 2. POST params to your user database
            val postUrl = URL("https://your-db-endpoint.com/user/update")
            val connection = postUrl.openConnection() as HttpURLConnection
            connection.apply {
                requestMethod = "POST"
                setRequestProperty("Content-Type", "application/json")
                doOutput = true
                outputStream.use { it.write(params.toByteArray(Charsets.UTF_8)) }
                // Check response code if needed
                if (responseCode != HttpURLConnection.HTTP_OK) {
                    throw Exception("POST request failed with code $responseCode")
                }
            }
            
            // Mark task as successful
            Result.success()
        } catch (e: Exception) {
            // If something goes wrong, tell WorkManager to retry later
            Result.retry()
        }
    }
}

3. Trigger the Task When Your App Is Closing

To detect when your app is moving to the background (and likely to be terminated), you can use Application.ActivityLifecycleCallbacks to track active activities. When all activities are stopped, enqueue the WorkManager task:

class MyApp : Application(), Application.ActivityLifecycleCallbacks {
    private var activeActivityCount = 0

    override fun onCreate() {
        super.onCreate()
        registerActivityLifecycleCallbacks(this)
    }

    override fun onActivityStarted(activity: Activity) {
        activeActivityCount++
    }

    override fun onActivityStopped(activity: Activity) {
        activeActivityCount--
        // When no activities are active, the app is in the background
        if (activeActivityCount == 0) {
            // Enqueue the sync task
            val syncRequest = OneTimeWorkRequestBuilder<SyncUserParamsWorker>()
                // Optional: Add retry policy (linear backoff here)
                .setBackoffCriteria(
                    BackoffPolicy.LINEAR,
                    OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                    TimeUnit.MILLISECONDS
                )
                .build()
            
            WorkManager.getInstance(this).enqueue(syncRequest)
        }
    }

    // Empty implementations for other lifecycle methods
    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
    override fun onActivityResumed(activity: Activity) {}
    override fun onActivityPaused(activity: Activity) {}
    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
    override fun onActivityDestroyed(activity: Activity) {}
}

Don't forget to declare your custom Application class in AndroidManifest.xml:

<application
    android:name=".MyApp"
    <!-- Rest of your app config -->
>
</application>

Key Notes for Your Use Case #

• Guaranteed Execution: Unlike onStop() or manual delays, WorkManager will ensure your task runs eventually—even if the device is restarted or the app is killed immediately after enqueuing.
• Background Thread Safety: The doWork() method runs on a dedicated background thread, so you won't hit NetworkOnMainThread exceptions.
• Passing Data: If you need to pass auth tokens or user IDs to the worker, use workDataOf() to attach input data when enqueuing the request, then retrieve it in the worker with inputData.getString("KEY_NAME").

Why Not Just Use a Delay Like Swift? #

Android's background restrictions (especially on API 26+) make manual delays risky. The system can kill your app mid-delay, and your task will still fail. WorkManager is designed to work within Android's rules, so it's far more reliable.

内容的提问来源于stack exchange，提问作者LiorD