如何通过Firebase Job Dispatcher实现后台定时保存位置到Firebase Database？

看来你需要实现一个不管应用处于运行还是关闭状态，都能定期把设备位置保存到Firebase Database的功能对吧？我来给你梳理下可行的方案——先针对你正在用的Firebase Job Dispatcher给出优化配置，再推荐Google现在更推荐的WorkManager方案，它对Android 8.0+的后台限制适配更友好，稳定性也更高。

一、Firebase Job Dispatcher 优化配置 #

你现在的代码只初始化了Dispatcher，还没完成完整的任务配置和执行逻辑，下面是补全后的实现：

1. 完整的App类任务调度代码 #

class App : Application() {
    private val TAG = App::class.java.simpleName

    override fun onCreate() {
        super.onCreate()
        Log.i("App", "App onCreate")

        val mAuthListener = FirebaseAuth.AuthStateListener { firebaseAuth ->
            val user = firebaseAuth.currentUser
            if (user != null) {
                Log.i(TAG, "用户已登录，开始调度位置上传任务")
                scheduleLocationUploadJob()
            } else {
                Log.i(TAG, "用户已登出，取消位置上传任务")
                cancelLocationUploadJob()
            }
        }
        FirebaseAuth.getInstance().addAuthStateListener(mAuthListener)
    }

    private fun scheduleLocationUploadJob() {
        val dispatcher = FirebaseJobDispatcher(GooglePlayDriver(this))
        val job = dispatcher.newJobBuilder()
            // 给任务设置唯一标识，方便后续取消或替换
            .setTag("location_upload_job")
            // 指定执行任务的Service，这个Service需要你自己实现
            .setService(LocationUploadJobService::class.java)
            // 设置为周期性任务
            .setRecurring(true)
            // 设置触发窗口：最短15分钟后执行，最长30分钟内执行（系统会在这个区间选时间触发，受系统调度限制）
            .setTrigger(Trigger.executionWindow(900, 1800))
            // 要求设备有网络时才执行（毕竟要上传到Firebase）
            .setConstraints(Constraint.ON_ANY_NETWORK)
            // 任务会一直存在，直到手动取消
            .setLifetime(Lifetime.FOREVER)
            // 如果已经存在同Tag的任务，直接替换它
            .setReplaceCurrent(true)
            .build()

        dispatcher.mustSchedule(job)
        Log.i(TAG, "位置上传任务已成功调度")
    }

    private fun cancelLocationUploadJob() {
        val dispatcher = FirebaseJobDispatcher(GooglePlayDriver(this))
        dispatcher.cancel("location_upload_job")
        Log.i(TAG, "位置上传任务已取消")
    }
}

2. 实现JobService类（执行位置获取和上传） #

你需要创建一个继承JobService的类，在这里完成获取当前位置并上传到Firebase的逻辑：

class LocationUploadJobService : JobService() {
    private val TAG = LocationUploadJobService::class.java.simpleName
    private lateinit var fusedLocationClient: FusedLocationProviderClient

    override fun onCreate() {
        super.onCreate()
        // 初始化位置客户端
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
    }

    override fun onStartJob(job: JobParameters): Boolean {
        Log.i(TAG, "开始执行位置上传任务")
        // 先检查是否有位置权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
            Log.e(TAG, "位置权限未授予，无法执行上传任务")
            jobFinished(job, false) // 任务结束，不需要重试
            return false
        }

        // 获取当前设备位置
        fusedLocationClient.lastLocation.addOnSuccessListener { location ->
            location?.let {
                // 获取当前登录用户的ID（确保用户已登录）
                val userId = FirebaseAuth.getInstance().currentUser?.uid ?: run {
                    Log.e(TAG, "未找到登录用户，无法上传位置")
                    jobFinished(job, false)
                    return@let
                }
                // 构建位置数据
                val locationData = hashMapOf(
                    "latitude" to it.latitude,
                    "longitude" to it.longitude,
                    "timestamp" to ServerValue.TIMESTAMP // 使用Firebase服务器时间
                )
                // 上传到Firebase Database
                val locationRef = FirebaseDatabase.getInstance().getReference("user_locations/$userId")
                locationRef.setValue(locationData)
                    .addOnSuccessListener {
                        Log.i(TAG, "位置上传成功")
                        jobFinished(job, false) // 任务完成，无需重试
                    }
                    .addOnFailureListener { e ->
                        Log.e(TAG, "位置上传失败: ${e.message}")
                        jobFinished(job, true) // 任务失败，请求系统重试
                    }
            } ?: run {
                Log.e(TAG, "无法获取当前设备位置")
                jobFinished(job, true) // 请求重试
            }
        }
        return true // 返回true表示任务在后台异步执行，执行完必须调用jobFinished
    }

    override fun onStopJob(job: JobParameters): Boolean {
        Log.i(TAG, "任务被系统强制停止，将请求重试")
        return true // 返回true表示需要重新调度任务
    }
}

3. 在Manifest中注册JobService #

别忘了在AndroidManifest.xml里注册刚才写的Service：

<service
    android:name=".LocationUploadJobService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.firebase.jobdispatcher.ACTION_EXECUTE"/>
    </intent-filter>
</service>

二、推荐使用WorkManager（更稳定的后台任务方案） #

其实Firebase Job Dispatcher已经是比较旧的库了，Google现在更推荐用WorkManager来处理后台任务，它能自动适配不同Android版本的后台限制，甚至设备重启后也能自动恢复任务，稳定性比Firebase Job Dispatcher好很多。

1. 添加WorkManager依赖 #

在你的Module级别build.gradle中添加依赖：

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

2. 创建Worker类（核心执行逻辑） #

用协程Worker来实现异步任务：

class LocationUploadWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {
    private val TAG = LocationUploadWorker::class.java.simpleName

    override suspend fun doWork(): Result {
        Log.i(TAG, "WorkManager开始执行位置上传任务")
        // 检查位置权限
        if (ContextCompat.checkSelfPermission(applicationContext, Manifest.permission.ACCESS_FINE_LOCATION)
            != PackageManager.PERMISSION_GRANTED) {
            Log.e(TAG, "位置权限未授予")
            return Result.failure()
        }

        // 异步获取位置（用协程await()替代回调）
        val fusedLocationClient = LocationServices.getFusedLocationProviderClient(applicationContext)
        val location = try {
            fusedLocationClient.lastLocation.await()
        } catch (e: Exception) {
            Log.e(TAG, "获取位置时出现异常: ${e.message}")
            return Result.retry() // 请求重试
        }

        location?.let {
            val userId = FirebaseAuth.getInstance().currentUser?.uid ?: return Result.failure()
            val locationData = hashMapOf(
                "latitude" to it.latitude,
                "longitude" to it.longitude,
                "timestamp" to ServerValue.TIMESTAMP
            )
            // 上传到Firebase
            return try {
                FirebaseDatabase.getInstance().getReference("user_locations/$userId")
                    .setValue(locationData)
                    .await()
                Log.i(TAG, "位置上传成功")
                Result.success()
            } catch (e: Exception) {
                Log.e(TAG, "上传失败: ${e.message}")
                Result.retry()
            }
        } ?: run {
            Log.e(TAG, "无法获取当前位置")
            return Result.retry()
        }
    }
}

3. 在App类中调度WorkManager任务 #

替换原来的Firebase Job Dispatcher代码：

class App : Application() {
    private val TAG = App::class.java.simpleName

    override fun onCreate() {
        super.onCreate()
        Log.i("App", "App onCreate")

        val mAuthListener = FirebaseAuth.AuthStateListener { firebaseAuth ->
            val user = firebaseAuth.currentUser
            if (user != null) {
                Log.i(TAG, "用户已登录，调度WorkManager位置上传任务")
                scheduleLocationUploadWithWorkManager()
            } else {
                Log.i(TAG, "用户已登出，取消WorkManager位置上传任务")
                cancelLocationUploadWithWorkManager()
            }
        }
        FirebaseAuth.getInstance().addAuthStateListener(mAuthListener)
    }

    private fun scheduleLocationUploadWithWorkManager() {
        // 设置任务执行的约束条件：需要网络
        val constraints = Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            // 可选：设置只有充电时才执行，节省电量
            // .setRequiresCharging(true)
            .build()

        // 创建周期性任务：每隔15分钟执行一次
        val uploadRequest = PeriodicWorkRequestBuilder<LocationUploadWorker>(15, TimeUnit.MINUTES)
            .setConstraints(constraints)
            .setInitialDelay(0, TimeUnit.MINUTES) // 立即执行第一次任务
            .build()

        // 调度唯一的周期性任务，如果已有同ID的任务就替换它
        WorkManager.getInstance(this).enqueueUniquePeriodicWork(
            "location_upload_work",
            ExistingPeriodicWorkPolicy.REPLACE,
            uploadRequest
        )
        Log.i(TAG, "WorkManager位置上传任务已调度")
    }

    private fun cancelLocationUploadWithWorkManager() {
        WorkManager.getInstance(this).cancelUniqueWork("location_upload_work")
        Log.i(TAG, "WorkManager位置上传任务已取消")
    }
}

几个关键注意事项 #

1. 权限问题：除了ACCESS_FINE_LOCATION/ACCESS_COARSE_LOCATION，Android 10及以上版本还需要申请ACCESS_BACKGROUND_LOCATION权限才能在后台获取位置。
2. 系统间隔限制：Android 8.0+对后台周期性任务有最小15分钟的间隔限制，这是系统为了省电强制设置的，无法绕过。
3. 设备重启：WorkManager默认支持设备重启后恢复任务，而Firebase Job Dispatcher需要额外监听开机广播来重新调度任务。

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