Android Jetpack 之使用 WorkManager

最新推荐文章于 2024-09-15 08:07:34 发布
最新推荐文章于 2024-09-15 08:07:34 发布
阅读量2.2k 收藏 1
点赞数 1
分类专栏： Jetpack 文章标签： android jetpack kotlin android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoshen2014/article/details/122460598
版权

Android Jetpack 之使用 WorkManager

简介

WorkManager 是 Android Jetpack 的一部分，它主要用来执行持续的后台工作，比如文件上传、日志上传等。

WorManager 可以执行一次性任务（One time），也可以执行周期性任务（Perodic）。

WorkManager也可以按照执行时间分为 3 类：

  1. 立即运行（Immediate）
  2. 长期运行（Long Running）
  3. 推迟运行（Deferrable）

使用方法

添加依赖

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"
}

定义 Worker

WorkManager 的所有任务都继承自 Worker 类。

重写 doWork 方法，执行任务，并且返回任务结果。

任务结果分 3 种：

  1. Result.success() 执行成功
  2. Result.failure() 执行失败
  3. Result.retry() 执行失败而且需要重试任务
class UploadWorker(appContext: Context, workerParams: WorkerParameters) :
        Worker(appContext, workerParams) {
    override fun doWork(): Result {
        uploadImages()
        return Result.success()
    }

    private fun uploadImages() {
    }
}

构造 WorkRequest

WorkRequest 是任务请求的基本单元，可以为 WorkRequest 添加参数、设置约束。

WorkRequest 分为 2 种：

  1. OneTimeWorkRequest 一次性工作请求
  2. PeriodicWorkRequest 周期性工作请求

OneTimeWorkRequest

使用 OneTimeWorkRequestBuilder 构造 OneTimeWorkRequest。

class WorkManagerActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        val uploadWorkRequest: WorkRequest = OneTimeWorkRequestBuilder<UploadWorker>()
                .build()
...
    }
}

PeriodicWorkRequest

使用 PeriodicWorkRequestBuilder 构造 PeriodicWorkRequest。

PeriodicWorkRequest 在构造时必须传入表示周期的时间维度，至少为 15 分钟。如果少于 15 分钟 PeriodicWorkRequest 会按照 15 分钟处理。

    fun buildPeriodicRequest(): WorkRequest {
        return PeriodicWorkRequestBuilder<UploadWorker>(15L, TimeUnit.MINUTES)
            .build()
    }

PeriodicWorkRequest

public final class PeriodicWorkRequest extends WorkRequest {

    /**
     * The minimum interval duration for {@link PeriodicWorkRequest} (in milliseconds).
     */
    @SuppressLint("MinMaxConstant")
    public static final long MIN_PERIODIC_INTERVAL_MILLIS = 15 * 60 * 1000L; // 15 minutes.
    
    ...
    public void setPeriodic(long intervalDuration) {
        if (intervalDuration < MIN_PERIODIC_INTERVAL_MILLIS) {
            Logger.get().warning(TAG, String.format(
                    "Interval duration lesser than minimum allowed value; Changed to %s",
                    MIN_PERIODIC_INTERVAL_MILLIS));
            intervalDuration = MIN_PERIODIC_INTERVAL_MILLIS;
        }
        setPeriodic(intervalDuration, intervalDuration);
    }

设置 InputData

setInputData 为 WorkRequest 增加任务参数。

    fun buildInputDataRequest(): WorkRequest {
        val data = Data.Builder()
            .putString("userName", "Bugra")
            .build()

        return OneTimeWorkRequestBuilder<OneTimeWorker>()
            .setInputData(data)
            .build()
    }

在 doWork 方法可以直接调用 ListenableWorker 的 inputData，使用 getString 读取参数。

class OneTimeWorker(context: Context, params: WorkerParameters) :
    CoroutineWorker(context, params) {
...
    override suspend fun doWork(): Result {
        val userName = inputData.getString("userName")
        ...
    }
}

设置 Constraints

使用 setConstraints 为 WorkRequest 设置参数。比如以下参数：

  1. setRequiredNetworkType 网络状态
  2. setRequiresBatteryNotLow 电量状态
  3. setRequiresCharging 充电状态
    fun buildConstraintsRequest(): WorkRequest {
        val constraints = buildConstraints()
        return OneTimeWorkRequestBuilder<OneTimeWorker>()
            .setConstraints(constraints)
            .build()
    }

    /**
     * constraints
     */
    fun buildConstraints(): Constraints {
        return Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .setRequiresBatteryNotLow(true)
            .setRequiresCharging(false)
            .build()
    }

使用 WorkManager 调度任务

构造 WorkRequest 后使用 WorkManager 把 WorkRequest 加入到任务队列。

class WorkManagerActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val uploadWorkRequest: WorkRequest = OneTimeWorkRequestBuilder<UploadWorker>()
                .build()

        val workManager: WorkManager = WorkManager.getInstance(this)
        workManager.enqueue(uploadWorkRequest)
    }
}

监听任务状态

使用 getWorkInfoByIdLiveData 方法从队列获取任务并且转换为可观察的 LiveData，便于观察任务的每个状态，在每种状态的回调做相应操作。

WorkInfo 有如下 6 种状态：

  1. ENQUEUED 入队
  2. RUNNING 运行中
  3. SUCCEEDED 运行成功
  4. FAILED 运行失败
  5. BLOCKED 被阻塞
  6. CANCELLED 取消
    public enum State {

        /**
         * Used to indicate that the {@link WorkRequest} is enqueued and eligible to run when its
         * {@link Constraints} are met and resources are available.
         */
        ENQUEUED,

        /**
         * Used to indicate that the {@link WorkRequest} is currently being executed.
         */
        RUNNING,

        /**
         * Used to indicate that the {@link WorkRequest} has completed in a successful state.  Note
         * that {@link PeriodicWorkRequest}s will never enter this state (they will simply go back
         * to {@link #ENQUEUED} and be eligible to run again).
         */
        SUCCEEDED,

        /**
         * Used to indicate that the {@link WorkRequest} has completed in a failure state.  All
         * dependent work will also be marked as {@code #FAILED} and will never run.
         */
        FAILED,

        /**
         * Used to indicate that the {@link WorkRequest} is currently blocked because its
         * prerequisites haven't finished successfully.
         */
        BLOCKED,

        /**
         * Used to indicate that the {@link WorkRequest} has been cancelled and will not execute.
         * All dependent work will also be marked as {@code #CANCELLED} and will not run.
         */
        CANCELLED;

        /**
         * Returns {@code true} if this State is considered finished.
         *
         * @return {@code true} for {@link #SUCCEEDED}, {@link #FAILED}, and * {@link #CANCELLED}
         *         states
         */
        public boolean isFinished() {
            return (this == SUCCEEDED || this == FAILED || this == CANCELLED);
        }
    }

定义 Worker

class OneTimeWorker(context: Context, params: WorkerParameters) :
    CoroutineWorker(context, params) {
    ...
    override suspend fun doWork(): Result {
        val userName = inputData.getString("userName")
        val random = Random.nextInt(0, 2)
        for (i in 1..10) {
            delay(1000)
            println("delay $i...")
        }
        val outputData = Data.Builder()
            .putInt("random", random)
            .build()
        return if (random == 0 ) {
            Result.Success(outputData)
        } else {
            Result.failure(outputData)
        }
    }
}

观察 Worker

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.e(TAG, "onCreate")

        val uploadWorkRequest = buildConstraintsRequest()

        val workManager: WorkManager = WorkManager.getInstance(this)
        workManager.enqueue(uploadWorkRequest)

//        2021-12-28 17:20:33.989 9202-9202 E/WorkManagerActivity: onCreate
//        2021-12-28 17:20:34.048 9202-9202 E/WorkManagerActivity: ENQUEUED
//        2021-12-28 17:20:34.051 9202-9202 E/WorkManagerActivity: RUNNING
//        2021-12-28 17:20:44.176 9202-9202 E/WorkManagerActivity: SUCCEEDED:0
        workManager.getWorkInfoByIdLiveData(uploadWorkRequest.id)
            .observe(this) { workInfo ->
                when (workInfo.state) {
                    WorkInfo.State.ENQUEUED -> {
                        Log.e(TAG, "ENQUEUED")
                    }
                    WorkInfo.State.RUNNING -> {
                        Log.e(TAG, "RUNNING")
                    }
                    WorkInfo.State.SUCCEEDED -> {
                        val outputData = workInfo.outputData
                        val random = outputData.getInt("random", -1)
                        Log.e(TAG, "SUCCEEDED:$random")
                    }
                    WorkInfo.State.FAILED -> {
                        val outputData = workInfo.outputData
                        val random = outputData.getInt("random", -1)
                        Log.e(TAG, "FAILED:$random")
                    }
                    WorkInfo.State.BLOCKED -> {
                        Log.e(TAG, "BLOCKED")
                    }
                    WorkInfo.State.CANCELLED -> {
                        Log.e(TAG, "CANCELLED")
                    }
                }
            }
    }

任务链

WorkManager 可以使用 beginWith、then、combine 等方法构造任务链，保证任务按照指定顺序运行。

先 beginWith 执行 compressRequest，再 then 执行 uploadWorkRequest。

class WorkManagerActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        ...

        val compressRequest = OneTimeWorkRequestBuilder<CompressWorker>()
            .build()
        val uploadWorkRequest = OneTimeWorkRequestBuilder<OneTimeWorker>()
            .build()

        val workManager: WorkManager = WorkManager.getInstance(this)
        workManager.beginWith(compressRequest)
            .then(uploadWorkRequest)
            .enqueue()

或者先 beginWith 同时执行 compressRequest、updateLocalRequest 两个任务，等两个任务都执行完毕后，使用 then 执行 uploadWorkRequest。

class WorkManagerActivity : AppCompatActivity() {
...
    override fun onCreate(savedInstanceState: Bundle?) {
        ...

        val compressRequest = OneTimeWorkRequestBuilder<CompressWorker>()
            .build()

        val updateLocalRequest = OneTimeWorkRequestBuilder<UpdateLocalWorker>().build()
        val uploadWorkRequest = OneTimeWorkRequestBuilder<OneTimeWorker>()
            .build()

        val workManager: WorkManager = WorkManager.getInstance(this)
        workManager.beginWith(listOf(compressRequest, updateLocalRequest))
            .then(uploadWorkRequest)
            .enqueue()

当有更复杂的任务链时，可以使用 WorkContinuation.combine 组合任务链。

compressRequest 和 updateLocalRequest 组成第一条任务链 workContinuation1。

oneTimeRequest 和 uploadWorkRequest 组成第二条任务链 workContinuation2。

使用 WorkContinuation.combine 组合两条任务链，两者都执行完毕后，执行 lastWorkRequest。

需要注意的是，任务链中如果前置任务执行失败，会导致后续无法执行。

class WorkManagerActivity : AppCompatActivity() {
...

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        val compressRequest = OneTimeWorkRequestBuilder<CompressWorker>().build()
        val updateLocalRequest = OneTimeWorkRequestBuilder<UpdateLocalWorker>().build()

        val oneTimeRequest = OneTimeWorkRequestBuilder<OneTimeWorker>().build()
        val uploadWorkRequest = OneTimeWorkRequestBuilder<UploadWorker>().build()

        val lastWorkRequest = OneTimeWorkRequestBuilder<UploadWorker>().build()

        val workManager: WorkManager = WorkManager.getInstance(this)
        val workContinuation1 = workManager.beginWith(compressRequest)
            .then(updateLocalRequest)
        val workContinuation2 = workManager.beginWith(oneTimeRequest)
            .then(uploadWorkRequest)
        WorkContinuation.combine(listOf(workContinuation1, workContinuation2))
            .then(lastWorkRequest)
            .enqueue();

实现原理

WorkManager.getInstance

WorkManager 使用 getInstance 方法得到单例，本质是 WorkManagerImpl 的 getInstance。

class WorkManagerActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Log.e(TAG, "onCreate")
...
        val workManager: WorkManager = WorkManager.getInstance(this)
        workManager.enqueue(uploadWorkRequest)
...
    }

public abstract class WorkManager {
    ...
    public static @NonNull WorkManager getInstance(@NonNull Context context) {
        return WorkManagerImpl.getInstance(context);
    }

WorkManagerImpl.getInstance

WorkManagerImpl 的 getInstance 使用 initialize 初始化 。

public class WorkManagerImpl extends WorkManager {

    public static @NonNull WorkManagerImpl getInstance(@NonNull Context context) {
       ...
            if (instance == null) {
                ...
                    initialize(
                            appContext,
                            ((Configuration.Provider) appContext).getWorkManagerConfiguration());
                 ...
            }

            return instance;
        }
    }

WorkManagerImpl.initialize

WorkManagerImpl 的 initialize 通过 context、configuration、WorkManagerTaskExecutor 构造 WorkManagerImpl 单例。

public class WorkManagerImpl extends WorkManager {

    public static void initialize(@NonNull Context context, @NonNull Configuration configuration) {
        synchronized (sLock) {
            ...
                if (sDefaultInstance == null) {
                    sDefaultInstance = new WorkManagerImpl(
                            context,
                            configuration,
                            new WorkManagerTaskExecutor(configuration.getTaskExecutor()));
                }
                sDelegatedInstance = sDefaultInstance;
            }
        }
    }

WorkManagerImpl 构造

在 WorkManagerImpl 的构造方法中新建了一个 Processor，用来处理任务，构造一个 List 得到任务调度器列表。 然后将 processor 传入 internalInit 初始化。

public class WorkManagerImpl extends WorkManager {

    public WorkManagerImpl(
            @NonNull Context context,
            @NonNull Configuration configuration,
            @NonNull TaskExecutor workTaskExecutor,
            @NonNull WorkDatabase database) {
        ...
        List<Scheduler> schedulers =
                createSchedulers(applicationContext, configuration, workTaskExecutor);
        Processor processor = new Processor(
                context,
                configuration,
                workTaskExecutor,
                database,
                schedulers);
        internalInit(context, configuration, workTaskExecutor, database, schedulers, processor);
    }

WorkManagerImpl.createSchedulers

WorkManagerImpl 的 createSchedulers 构造了 2 个 Scheduler。

  1. createBestAvailableBackgroundScheduler 用来选择合适的后台调度器
  2. GreedyScheduler 用来调度执行没有任何约束的任务
public class WorkManagerImpl extends WorkManager {

    public List<Scheduler> createSchedulers(
            @NonNull Context context,
            @NonNull Configuration configuration,
            @NonNull TaskExecutor taskExecutor) {

        return Arrays.asList(
                Schedulers.createBestAvailableBackgroundScheduler(context, this),
                // Specify the task executor directly here as this happens before internalInit.
                // GreedyScheduler creates ConstraintTrackers and controllers eagerly.
                new GreedyScheduler(context, configuration, taskExecutor, this));
    }

Schedulers.createBestAvailableBackgroundScheduler

Schedulers 的 createBestAvailableBackgroundScheduler 根据当前手机版本选择不同的调度器，用来在 app 处于后台时调用系统级别的服务执行任务。

  1. 系统版本大于等于 23。使用 SystemJobScheduler，启动 SystemJobService 执行任务。
  2. 系统版本小于 23。通过反射查看手机是否支持 GCM 谷歌云消息服务，如果支持则返回 GCM 调度器 GcmScheduler
  3. 如果系统版本小于 23且不支持 GCM。使用 SystemAlarmScheduler，通过 AlarmManager 执行任务。
public class Schedulers {

    static Scheduler createBestAvailableBackgroundScheduler(
            @NonNull Context context,
            @NonNull WorkManagerImpl workManager) {

        Scheduler scheduler;

        if (Build.VERSION.SDK_INT >= WorkManagerImpl.MIN_JOB_SCHEDULER_API_LEVEL) {
            scheduler = new SystemJobScheduler(context, workManager);
            setComponentEnabled(context, SystemJobService.class, true);
            Logger.get().debug(TAG, "Created SystemJobScheduler and enabled SystemJobService");
        } else {
            scheduler = tryCreateGcmBasedScheduler(context);
            if (scheduler == null) {
                scheduler = new SystemAlarmScheduler(context);
                setComponentEnabled(context, SystemAlarmService.class, true);
                Logger.get().debug(TAG, "Created SystemAlarmScheduler");
            }
        }
        return scheduler;
    }

总结

WorkManager 适合做持续性的后台任务，比如日志、图片、文件上传等。

相比普通的后台任务，WorkManager 可以做一次性任务、周期性任务、推迟任务，它也可以在 app 或者系统重启时重新调度任务，设置各种系统约束。WorkManager 还可以将任务组合成任务链的形式，保证任务的调度顺序。

从实现原理上来说，WorkManager 会根据不同的系统版本，选择 JobService、GCM 或者 AlarmMananger 执行任务。

okclouderx
关注
专栏目录
Android Jetpack（八）WorkManager
01-03
 WorkManager 是 Jetpack 组件库的一个组件，负责管理后台任务。  WorkManager API 可以让你更加容易的管理一些后台任务，即使你的应用是退出或者设备重启的状态。  WorkManager 适用于任务的延迟执行，不需要...
Android8.0后时代的后台任务JetPack-WorkManager详解
chuanao8829的博客
08-07 1006
本篇文章已授权微信公众号 guolin_blog （郭霖）独家发布 WorkManager详解 一、回顾一下以前的做法 以前我们在处理后台任务时，一般都是使用Service(含IntentService）或者线程/线程池，而Service不受页面生命周期影响，可以常驻后台，所以很适合做一些定时...
WorkManager的学习二
Mr_Tony的专栏
07-04 799
WorkManager的学习二，观察任务的执行状态
Android WorkManager 实战指南
gitblog_00050的博客
09-15 913
Android WorkManager 实战指南 codelab-android-workmanager 项目地址: https://gitcode.com/gh_mirrors/an/android-workmanager ...
WorkManager: 周期性任务
谷歌开发者
10-11 1415
WorkManager 是一个 Android Jetpack 扩展库，它可以让您轻松规划那些可延后、异步但又需要可靠运行的任务。对于绝大部分后台执行任务来说，使用 WorkManage...
android WorkMannager 解析
qq_46054898的博客
05-17 656
android WorkMannager 解析
WorkManager完全解析+重构轮询系统，看完直接怼产品经理
m0_61418427的博客
09-06 291
} } } 在上面的MyWorker实例中，继承了Worker 并且重写了doWork()方法，需要注意的是doWork()方法是有返回值Worker.Result的，可以在任务执行成功是返回**Worker.Result.SUCCESS**，在任务执行出现异常时返回**Worker.Result.FAILURE** doWork()方法的返回值主要有三种 1、**Worker.Result.SUCCESS** 表示任务执行成功 2、**Worker.Result.FAILURE** 表示任务...
Android—Jetpack教程（九）
qq_30382601的博客
12-08 845
前言 在上一篇中，主要讲解了Jetpack对应Navigation组件，在这一篇中，将会对应WorkManager进行详解！
Android Jetpack架构组件（九）WorkManager源码篇
01-03
上一篇讲解了WorkManager使用篇，本篇我们就从源码角度来分析WorkManager的工作原理。 WorkManager的原理 上一篇WorkManager使用篇讲解了如何使用WorkManager。本篇我们就按照上一篇的使用步骤来分析源码。 生成...
Android开发：Android Jetpack：10.WorkManager后台任务处理.pdf
最新发布
10-24
Android开发：Android Jetpack：10.WorkManager后台任务处理.pdf
android-workmanager:WorkManager的示例，一个架构组件，是Android Jetpack的一部分
05-16
Android Jetpack〜工作管理器介绍在2018年I / O大会上，谷歌发布了 ，这是一系列库，工具和体系结构指南的集合，旨在加速和简化出色的Android应用程序的开发。 这些库之一是。 WorkManager库为需要保证执行的一次性...
Elements of Android Jetpack 0.3 - 2019 by Mark L. Murphy
03-01
Murphy撰写的一本关于Android开发的专业书籍，重点介绍了Android Jetpack框架的使用和理解。该书适用于已经有一定Android基础的开发者，旨在帮助他们掌握Jetpack组件库，提升应用开发效率和质量。 Android Jetpack...
Android架构组件JetPack之WorkManager完全解析（五）
2401_83620927的博客
03-19 1051
由上面的执行时间可以看出，PeriodicWorkRequest并不是准确的按照24小时来执行，会有一定的时间延迟。因此如果需要准确的间隔时间来执行任务的话不能使用PeriodicWorkRequest。.build();= null) {可以给任务加一些运行的Constraints条件，比如说当设备空闲时或者正在充电或者连接WiFi时执行任务。.build();.build();WorkManager管理WorkRequest队列。
APP被杀也能执行的任务，WorkManager介绍以及用法
maniuT的博客
11-16 1087
下面是允许你定义需要执行的任务，包括延迟执行、定时执行和根据触发条件执行的任务。你可以创建单次或重复性任务。你可以创建任务链，将多个任务按顺序排列，以确保它们以特定顺序执行。这对于处理复杂的工作流非常有用。支持约束，这意味着你可以指定任务执行的条件，例如在特定网络状态下、设备充电时等。这有助于减少不必要的任务执行，提高电池寿命和性能。能够选择最佳的后台任务调度方法，以适应不同Android版本和制造商的设备。
Android之任务调度WorkManager和JobSchedule的使用
Vaccae的博客
08-30 3323
学更好的别人，做更好的自己。——《微卡智享》本文长度为5347字，预计阅读11分钟前言调度任务也是最近产品中需要用的，定时与后台进行数据同步，研究了几种方法后，觉得还是JobSchedul...
WorkManager从入门到实践，有这一篇就够了
emike的专栏
09-01 852
前言 上一次我们对Paging的应用进行了一次全面的分析，这一次我们来聊聊WorkManager。 如果你对Paging还未了解，推荐阅读这篇文章： 本来这一篇文章上周就能够发布出来，但我写文章有一个特点，都会结合具体的Demo来进行阐述，而WorkManager的Demo早就完成了，只是要结合文章一起阐述实在需要时间，上周自身原因也就延期了，想想还是写代码容易啊... 哎呀不多说了，进入正题！ WorkManager WorkManager是什么？官方给的解释是：它对可延期任务操作非常简单，同
Android WorkManager使用的坑
thezprogram的专栏
07-01 4002
使用流程 1 应用启动时，网络请求获取用户信息 2 获取成功，调用WorkerManager的enqueue传入自定义的Wroker启动任务 3 在任务的doWrok中调用用户信息类中的方法进行操作 出现的问题： 当设备重启后，闪退，报空指针异常。 异常位置是在doWrok()方法体中。 通过打log打印执行时间发现，设备重启时，doWrok就会执行，在获取用户信息之前 导致userInfo为空...
Jetpack架构组件库：WorkManager
川峰的博客
01-28 1161
工作使用Worker类定义。Worker类的doWork()方法在提供的后台线程上异步运行。如需为创建一些要运行的工作，请继承Worker类并重写doWork()方法。从doWork()返回的Result会通知服务工作是否成功，以及工作失败时是否应重试工作。：工作成功完成。：工作失败。：工作失败，应根据其重试政策在其他时间尝试。默认情况下，当您的应用启动时，WorkManager 使用适合大多数应用的合理选项自动进行配置。
关于OPPO手机适配屏蔽的API -- WorkManager不生效
大梦想家
08-12 3582
如标题所示，在oppo手机上这个api是不生效的 workmanager 18年I/O大会，google发布了 Android Jetpack.它是一些列的库，工具和架构指南，可以帮助你轻松快速的构建以优秀的App。在Android Jetpack中，Google团队中发布了一个专门用于调度和管理后台任务的库，它被称为WorkManager。 详细功能使用请自行查阅，主要用于我们执行一些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值