Android聊天应用：实现杀进程后网络恢复自动同步未发消息

正在开发一款聊天应用，需要实现网络恢复时自动同步未发送消息的功能：无论应用处于前台、后台还是被杀死状态，只要设备重新联网，未发送的消息都能自动发送，达到类似WhatsApp的效果。

已尝试的方案 #

1. 基于android.net.conn.CONNECTIVITY_CHANGE的广播接收器 #

仅在应用活跃（前台或后台）时有效，应用被杀后完全失效。

2. 前台服务（Foreground Service） #

会持续显示通知，体验不佳，且额外消耗电量，不符合需求。

3. AndroidX.Work.Worker #

使用定期轮询的工作请求，代码如下：

PeriodicWorkRequest networkCheckingPeriodicWork = PeriodicWorkRequest.Builder.
                From<ConnectivityChangeWroker>(repeatInterval:30, repeatIntervalTimeUnit: Java.Util.Concurrent.TimeUnit.Minutes, flexInterval:25, flexIntervalTimeUnit:Java.Util.Concurrent.TimeUnit.Minutes)
                .SetConstraints(new Constraints.Builder().SetRequiredNetworkType(AndroidX.Work.NetworkType.Connected)
                .SetRequiredNetworkType(AndroidX.Work.NetworkType.Unmetered).Build()).Build();

WorkManager.Instance.EnqueueUniquePeriodicWork("", ExistingPeriodicWorkPolicy.Replace, networkCheckingPeriodicWork);


public class ConnectivityChangeWroker : AndroidX.Work.Worker
{
    public ConnectivityChangeWroker(Context context, WorkerParameters workerParameters) : base(context, workerParameters)
    {

    }

    public override Result DoWork()
    {
        try
        {
            //Start synch service
            return Result.InvokeSuccess();
        }
        catch (Exception)
        {
            return Result.InvokeFailure();
        }
    }
}

实际效果未达预期：该方案本质是定期轮询网络状态，无法做到网络恢复时立即触发同步。

4. JobService #

实现代码如下：

Java.Lang.Class javaClass = Java.Lang.Class.FromType(typeof(ConnectivityChangeJob));
ComponentName component = new ComponentName(Application.Context, javaClass);

JobInfo jobInfo = new JobInfo.Builder(1, component)
                         .SetRequiredNetworkType(Android.App.Job.NetworkType.Any)
                         .SetOverrideDeadline(5000)
                         .SetPersisted(true)
                         .Build();

JobScheduler jobScheduler = (JobScheduler)GetSystemService(JobSchedulerService);
jobScheduler.Schedule(jobInfo);


[Service(Name = "Extintores.ConnectivityChangeJob", Permission = "android.permission.BIND_JOB_SERVICE")]
public class ConnectivityChangeJob : JobService
{
    private Intent startServiceIntent;

    public ConnectivityChangeJob()
    {

    }

    public override bool OnStartJob(JobParameters jobParams)
    {
       //Start synchService
        return true;
    }

    public override bool OnStopJob(JobParameters jobParams)
    {
        return true; //Reschedule the job
    }
}

问题：OnStartJob仅在应用首次打开时触发一次，后续网络状态变化不再执行。

可行实现方案 #

方案一：优化WorkManager配置（推荐） #

放弃PeriodicWorkRequest，改用带网络约束的OneTimeWorkRequest，结合应用活跃时的网络监听，覆盖所有场景：

1. 定义联网触发的工作请求

var constraints = new Constraints.Builder()
    .SetRequiredNetworkType(NetworkType.Connected) // 可根据需求改为Unmetered（仅无限网络）
    .Build();

var syncWork = new OneTimeWorkRequest.Builder<ConnectivityChangeWorker>()
    .SetConstraints(constraints)
    .SetBackoffCriteria(BackoffPolicy.Exponential, TimeSpan.FromSeconds(10)) // 失败后指数退避重试
    .Build();

// 唯一工作，避免重复入队
WorkManager.Instance.EnqueueUniqueWork("SyncUnsentMessages", ExistingWorkPolicy.Replace, syncWork);

2. 应用活跃时监听网络变化，立即触发同步

var connectivityManager = (ConnectivityManager)GetSystemService(Context.ConnectivityService);
var networkCallback = new NetworkCallbackImpl();
connectivityManager.RegisterDefaultNetworkCallback(networkCallback);

class NetworkCallbackImpl : ConnectivityManager.NetworkCallback
{
    public override void OnAvailable(Network network)
    {
        base.OnAvailable(network);
        // 应用活跃时直接触发同步
        SyncUnsentMessages();
        // 确保WorkManager任务已入队，覆盖应用被杀场景
        EnqueueSyncWork();
    }
}

3. 实现Worker内的同步逻辑

public class ConnectivityChangeWorker : AndroidX.Work.Worker
{
    public ConnectivityChangeWorker(Context context, WorkerParameters workerParameters) : base(context, workerParameters)
    {
    }

    public override Result DoWork()
    {
        try
        {
            SyncUnsentMessages();
            return Result.Success();
        }
        catch (Exception ex)
        {
            // 根据异常类型决定是否重试
            return Result.Retry();
        }
    }

    private void SyncUnsentMessages()
    {
        // 从本地数据库读取未发送消息，逐一发送
        // 发送成功后更新本地状态，避免重复发送
    }
}

方案二：优化JobService配置 #

调整JobInfo参数，确保网络变化时重复触发：

public override bool OnStartJob(JobParameters jobParams)
{
    // 异步执行同步逻辑，避免阻塞主线程
    new Thread(() => {
        SyncUnsentMessages();
        // 执行完成后重新调度Job，确保下次网络变化时触发
        JobScheduler jobScheduler = (JobScheduler)GetSystemService(Context.JobSchedulerService);
        jobScheduler.Schedule(GetJobInfo());
        jobFinished(jobParams, false);
    }).Start();
    return true;
}

private JobInfo GetJobInfo()
{
    Java.Lang.Class javaClass = Java.Lang.Class.FromType(typeof(ConnectivityChangeJob));
    ComponentName component = new ComponentName(Application.Context, javaClass);
    return new JobInfo.Builder(1, component)
            .SetRequiredNetworkType(Android.App.Job.NetworkType.Connected)
            .SetPersisted(true) // 设备重启后保留任务
            .Build();
}

关键注意事项 #

• 权限配置：在AndroidManifest.xml添加必要权限

  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  <uses-permission android:name="android.permission.INTERNET" />
  <!-- Android 8.0+ 后台执行权限 -->
  <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
  

  需引导用户将应用加入电池优化白名单，否则后台任务可能被系统限制。
• 本地数据持久化：未发送消息必须存储到本地数据库（如Room），确保应用被杀后数据不丢失。
• 去重机制：为每条消息添加唯一标识，发送成功后更新本地状态，防止重复发送。

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