欢迎进入jdb电子官方网站!

咨询热线:400-156-4567

Android开发之定时任务(AlarmManager、WorkManager)

发布时间:2024-01-26 01:06:54

Android 程序的定时任务主要有AlarmManager、WorkManager两种。

一、AlarmManager

AlarmManager,又称闹钟,可以设置一次性任务,周期重复任务,定时重复任务。
AlarmManager 通过 PendingIntent 传递要执行的任务程序,可以是广播、跳转页面、后台服务、前台服务等。

1、PendingIntent介绍

本节参考文章:https://zhuanlan.zhihu.com/p/544564416

PendingIntent 是一种延迟的 Intent,表示一种延迟执行的意图操作。
PendingIntent 一种是支持授权其他应用以当前应用的身份执行包装的 Intent 操作的系统特性。
从结构上来说,PendingIntent 是 Intent 的包装类

使用代码示例:

 Intent intent = new Intent(this, MyIntentService.class);
 PendingIntent serviceIntent = PendingIntent.getService(this, requestCode, intent,PendingIntent.FLAG_UPDATE_CURRENT| PendingIntentPendingIntent.FLAG_IMMUTABLE);
PendingIntent通过如下方法获取各种场景实例:
  • PendingIntent.getBroadcast(),广播,类似 Context.sendBroadcast(),Intent对应的class必须是BroadcastReceiver子类
  • PendingIntent.getActivity(),跳转活动页面,类似 Context.startActivity(Intent),Intent对应的class必须是一个Activity
  • PendingIntent.getService(),后台服务,类似 Context.startService(),Intent对应的class必须是Service子类
  • PendingIntent.getForegroundService(),前台服务,类似 Context.startForegroundService()

简单说明下创建 PendingIntent 的 4 个参数:

1、context: 当前应用的上下文,PendingIntent 将从中抽取授权信息;
2、requestCode: PendingIntent 的请求码,与 Intent 的请求码类似;
3、intent: 最终的意图操作;
4、flag: 控制标记位。

创建 PendingIntent 时有一个容易犯错的地方需要注意:重复调用 PendingIntent.getActivity() 等创建方法不一定会返回新的对象,系统会基于两个要素判断是否需要返回相同的对象

  • 要素 1 - requestCode: 不同的 requestCode 会被认为不同的 PendingIntent 意图;
  • 要素 2 - Intent: 不同的 Intent 会被认为不同的 PendingIntent 意图,但并不是 Intent 中所有的参数都会参与计算,而是仅包含 Intent.filterEquals() 方法考虑的参数,即:action、data、type、identity、class 和 categories,但不包括 extras。
PendingIntent 标记位
  • FLAG_IMMUTABLE: 不可变标记位,将约束外部应用消费 PendingIntent 修改其中的 Intent;
  • FLAG_MUTABLE: 可变标记位,不约束外部应用消费 PendingIntent 修改其中的 Intent;
  • FLAG_UPDATE_CURRENT: 更新标记位 1,如果系统中已经存在相同的 PendingIntent,那么将保留原有 PendingIntent 对象,而更新其中的 Intent。即使不可变 PendingIntent,依然可以在当前应用更新;
  • FLAG_CANCEL_CURRENT: 更新标记位 2,如果系统中已经存在相同的 PendingIntent,那么将先取消原有的 PendingIntent,并重新创建新的 PendingIntent。
  • FLAG_NO_CREATE: 更新标记位 3,如果系统中已经存在相同的 PendingIntent,那么不会重新创建,而是直接返回 null;
  • FLAG_ONE_SHOT: 一次有效标记位,PendingIntent 被消费后不支持重复消费,即只能使用一次。

2、闹钟任务设置

1、闹钟执行方法设置

1)一次性执行

alarmMgr.set(@AlarmType int type, long triggerAtMillis, PendingIntent operation)

2)重复执行

setRepeating()和setInexactRepeating()都可以设置重复任务,官方推荐使用setInexactRepeating()

alarmMgr.setInexactRepeating(@AlarmType int type, long triggerAtMillis, long intervalMillis, PendingIntent operation)

type,闹钟类型
triggerAtMillis,首次触发时间,毫秒数
intervalMillis,每次执行时间间隔,毫秒数

2、闹钟类型说明:

  • ELAPSED_REALTIME - 基于自设备启动以来所经过的时间触发待定 intent,但不会唤醒设备。经过的时间包括设备处于休眠状态期间的任何时间。
  • ELAPSED_REALTIME_WAKEUP - 唤醒设备,并在自设备启动以来特定时间过去之后触发待定 Intent。
  • RTC - 在指定的时间触发待定 Intent,但不会唤醒设备。
  • RTC_WAKEUP - 唤醒设备以在指定的时间触发待定 Intent。

3、AlarmManager代码示例

1、一次性任务,1分钟后执行

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT| PendingIntent.FLAG_IMMUTABLE);

alarmMgr.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + 60 * 1000, alarmIntent);

2、重复任务,30分钟后执行,每间隔30分钟执行1次,注意:最短间隔时间是1分钟

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, MyIntentService.class);
alarmIntent = PendingIntent.getService(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT| PendingIntent.FLAG_IMMUTABLE);

alarmMgr.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
        SystemClock.elapsedRealtime() + AlarmManager.INTERVAL_HALF_HOUR,
        AlarmManager.INTERVAL_HALF_HOUR, alarmIntent);

3、在下午 2:00 左右唤醒设备并触发闹钟,并在每天的同一时间重复一次

// 设置闹钟在下午2:00执行
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 14);

// 设置每隔一天执行一次
alarmMgr.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        AlarmManager.INTERVAL_DAY, alarmIntent);

4、在上午 8:30 准时唤醒设备并触发闹钟,此后每 20 分钟触发一次

private AlarmManager alarmMgr;
private PendingIntent alarmIntent;
...
alarmMgr = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(context, AlarmReceiver.class);
alarmIntent = PendingIntent.getBroadcast(context, 0, intent, 0);

// 设置闹钟在上午8:30 执行
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.HOUR_OF_DAY, 8);
calendar.set(Calendar.MINUTE, 30);

// 设置闹钟每隔20分钟触发一次
alarmMgr.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
        1000 * 60 * 20, alarmIntent);

4、取消Alarm任务

使用PendingIntent.FLAG_NO_CREATE获取已存在的PendingIntent,然后执行cancel()方法

Intent intent = new Intent(this, MyIntentService.class);
AlarmManager alarmManager = (AlarmManager) this.getSystemService(Context.ALARM_SERVICE);
PendingIntent pendingIntent = PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_NO_CREATE|PendingIntent.FLAG_IMMUTABLE);
if (pendingIntent != null && alarmManager != null) {
    Log.i("cancelAlarm", "cancelAlarm: " + pendingIntent);
    pendingIntent.cancel();
    alarmManager.cancel(pendingIntent);
} else {
    Log.i("cancelAlarm", "not found Alarm !");
}

5、在设备重启时启动闹钟

1)添加设备权限


2)实现 BroadcastReceiver 以接收广播,判断设备启动事件

public class SampleBootReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
            // 判断设备启动事件
        }
    }
}

3)配置 Intent 过滤器过滤器,添加android.intent.action.BOOT_COMPLETED

<receiver android:name=".SampleBootReceiver" android:enabled="true">
    <intent-filter>
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
    intent-filter>
receiver>

二、使用 WorkManager 调度任务

本节参考官方文档:https://developer.android.google.cn/topic/libraries/architecture/workmanager/basics

WorkManager 是适合用于持久性工作的推荐解决方案。如果工作始终要通过应用重启和系统重新启动来调度,便是持久性的工作。由于大多数后台处理操作都是通过持久性工作完成的,因此 WorkManager 是适用于后台处理操作的主要推荐 API。

  • 立即,一次性,OneTimeWorkRequest 和 Worker。如需处理加急工作,请对 OneTimeWorkRequest 调用 setExpedited()。
  • 长期运行,一次性或定期,任意 WorkRequest 或 Worker。在工作器中调用 setForeground() 来处理通知。
  • 可延期,一次性或定期,PeriodicWorkRequest 和 Worker。

WorkManager 适用于需要可靠运行的工作,即使用户导航离开屏幕、退出应用或重启设备也不影响工作的执行。例如:

  • 向后端服务发送日志或分析数据。
  • 定期将应用数据与服务器同步。

WorkManager 不适用于那些可在应用进程结束时安全终止的进程内后台工作。它也并非对所有需要立即执行的工作都适用的通用解决方案。

WorkManager 的使用简单描述3个步骤

  1. 定义工作,创建Worker实现类
  2. 创建工作请求,WorkRequest
  3. 将 WorkRequest 提交给系统

1、引入依赖包

将以下依赖项添加到应用的build.gradle文件中

dependencies {
    def work_version = "2.7.1"

    // (Java only)
    implementation "androidx.work:work-runtime:$work_version"

    // Kotlin + coroutines
    implementation "androidx.work:work-runtime-ktx:$work_version"

    // optional - RxJava2 support
    implementation "androidx.work:work-rxjava2:$work_version"

    // optional - GCMNetworkManager support
    implementation "androidx.work:work-gcm:$work_version"

    // optional - Test helpers
    androidTestImplementation "androidx.work:work-testing:$work_version"

    // optional - Multiprocess support
    implementation "androidx.work:work-multiprocess:$work_version"
}

2、定义工作

工作使用 Worker 类定义。doWork() 方法在 WorkManager 提供的后台线程上异步运行。

如需为 WorkManager 创建一些要运行的工作,请扩展 Worker 类并替换 doWork() 方法。例如,如需创建上传图像的 Worker,您可以执行以下操作:

public class UploadWorker extends Worker {
    public UploadWorker(
            @NonNull Context context,
            @NonNull WorkerParameters params) {
        super(context, params);
    }

    @Override
    public Result doWork() {
        // 获取传入的参数
        String name = getInputData().getString("name");
        Log.i("Worker", "uploadImages: name: "+ name);
        uploadImages();
        return Result.success();
    }

    private void uploadImages() {
        Log.i("Worker", "uploadImages: test2");
    }
}

从 doWork() 返回的 Result 会通知 WorkManager 服务工作是否成功,以及工作失败时是否应重试工作。

  • Result.success():工作成功完成。
  • Result.failure():工作失败。
  • Result.retry():工作失败,应根据其重试政策在其他时间尝试。

3、创建 WorkRequest

定义工作后,必须使用 WorkManager 服务进行调度该工作才能运行。对于如何调度工作,WorkManager 提供了很大的灵活性。您可以将其安排为在某段时间内定期运行,也可以将其安排为仅运行一次。

不论您选择以何种方式调度工作,请始终使用 WorkRequest。Worker 定义工作单元,WorkRequest(及其子类)则定义工作运行方式和时间。

  • OneTimeWorkRequest,一次性任务
  • PeriodicWorkRequest,周期任务

1)OneTimeWorkRequest 示例

WorkRequest uploadWorkRequest =
   new OneTimeWorkRequest.Builder(UploadWorker.class)
       .build();

2)PeriodicWorkRequest 示例

PeriodicWorkRequest 最短执行周期是15分钟,如果设置的循环周期小于15分钟也会被设置为15分钟
最好给WorkRequest设置Tag值,以便在启动时,删除旧的执行任务,防止重复执行

PeriodicWorkRequest uploadWorkRequest =
        new PeriodicWorkRequest.Builder(UploadWorker.class, 15, TimeUnit.MINUTES)
                // Constraints
                .setInitialDelay(10, TimeUnit.SECONDS)
                .addTag("task")
                .setInputData(new Data.Builder()
                        .putString("name","Hello")
                        .build())
                .build();

4、将 WorkRequest 提交给系统

最后,您需要使用 enqueue() 方法将 WorkRequest 提交到 WorkManager。

WorkManager
    .getInstance(this)
    .enqueue(uploadWorkRequest);

如果要要取消任务可使用方法

// 取消所有任务
WorkManager.getInstance(this).cancelAllWork();
// 取消指定任务
WorkManager.getInstance(this).cancelAllWorkByTag("task");

其他配置

1、执行加急工作

您可以控制当应用达到其执行配额时加急工作会发生什么情况。如需继续,您可以传递 setExpedited():

  • OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST,这会导致作业作为普通工作请求运行。上述代码段演示了此操作。
  • OutOfQuotaPolicy.DROP_WORK_REQUEST,这会在配额不足时导致请求取消。
OneTimeWorkRequest request = new OneTimeWorkRequestBuilder<T>()
    .setInputData(inputData)
    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .build();

2、工作约束

约束可确保将工作延迟到满足最佳条件时运行

  • NetworkType 约束运行工作所需的网络类型。例如 Wi-Fi (UNMETERED)。
  • BatteryNotLow 如果设置为 true,那么当设备处于“电量不足模式”时,工作不会运行。
  • RequiresCharging 如果设置为 true,那么工作只能在设备充电时运行。
  • DeviceIdle 如果设置为 true,则要求用户的设备必须处于空闲状态,才能运行工作。在运行批量操作时,此约束会非常有用;若是不用此约束,批量操作可能会降低用户设备上正在积极运行的其他应用的性能。
  • StorageNotLow 如果设置为 true,那么当用户设备上的存储空间不足时,工作不会运行。
Constraints constraints = new Constraints.Builder()
       .setRequiredNetworkType(NetworkType.UNMETERED)
       .setRequiresCharging(true)
       .build();

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setConstraints(constraints)
               .build();

3、重试和退避政策

如果您需要让 WorkManager 重试工作,可以从工作器返回 Result.retry()。然后,系统将根据退避延迟时间和退避政策重新调度工作。

  • 退避延迟时间指定了首次尝试后重试工作前的最短等待时间。此值不能超过 10 秒(或 MIN_BACKOFF_MILLIS)。
  • 退避政策定义了在后续重试过程中,退避延迟时间随时间以怎样的方式增长。WorkManager 支持 2 个退避政策,即 LINEAR(线性) 和 EXPONENTIAL(指数)。

每个工作请求都有退避政策和退避延迟时间。默认政策是 EXPONENTIAL,延迟时间为 10 秒,但您可以在工作请求配置中替换此设置。

WorkRequest myWorkRequest =
       new OneTimeWorkRequest.Builder(MyWork.class)
               .setBackoffCriteria(
                       BackoffPolicy.LINEAR,
                       OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                       TimeUnit.MILLISECONDS)
               .build();

4、链接工作,执行多个工作

您可以使用 WorkManager 创建工作链并将其加入队列。工作链用于指定多个依存任务并定义这些任务的运行顺序。
如需创建工作链,您可以使用 WorkManager.beginWith(OneTimeWorkRequest) 或 WorkManager.beginWith(List),这会返回 WorkContinuation 实例

WorkManager.getInstance(myContext)
   // Candidates to run in parallel
   .beginWith(Arrays.asList(plantName1, plantName2, plantName3))
   // Dependent work (only runs after all previous work in chain)
   .then(cache)
   .then(upload)
   // Call enqueue to kick things off
   .enqueue();

总结

  • AlarmManager,会使设备从低电耗模式中唤醒。因此,它在电源和资源管理方面来讲并不高效。AlarmManager 仅适合用于精确闹钟或通知(例如日历活动)场景,而不适用于后台工作。
  • WorkManager,使用更加简单,适用于更加复杂的场景,兼容性更好