Android Jetpack 从使用到源码深耕调度任务组件WorkManager 从实践到原理

Posted 2023-04-03 itbird01

本文，我们对Jetpack的调度任务组件WorkManager ，由使用入手，对其源码进行深入学习、总结一下。

1.问题

研究这个框架之前，我们基于自己已有的知识体系，想一些问题，给自己设定一些目标，带着目标和问题，去阅读这块的源码，相信收获会更多更深一些。
1） WorkManager 是做什么的？
2） WorkManager 怎么用？
3） WorkManager 是如何实现的？我们自己如何去实现这样一个框架，如何实现？
4）尝试先用自己的已有知识体系，实现一下 WorkManager
5） WorkManager 如何实现调度任务管理、执行的？是否就是对ThreadPool+Runnable进行的一次封装实现？
6）WorkManager 的官方实现源码中，有哪些可以改进的地方？
希望读完本文，大家对于这些问题，都有自己的答案。

2.背景

使用之前，我们首先需要知道，Google开发公开这个组件的立意是什么？

我们之前讲过Handler、Looper、Thread、MQ、Message相关源码，以及相关的关系 ，从而也引出了这样一个基础知识点，Thread 是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，那么它可以是while true一直占用cpu资源运行，但是具体运行什么，需要由外界交

Android Jetpack 组建介绍——Lifecycler

参考Android Jetpack架构组件之 Lifecycle（源码篇）

源码分析

关于Lifecycle的使用考上一篇文章Android Jetpack框架之 Lifecycles（使用篇），从使用的方法中我们知道Lifecycle的实现主要依赖：LifecycleObserver、LifecycleOwner；通过像Owner注册Observer实现感知Owner的生命周期，下面一起看看源码是如何巧妙设计的；

生命周期观察者：LifecycleObserver

// 实现LifecycleObserver
class MyObserver(var lifecycle: Lifecycle, var callback: CallBack) : LifecycleObserver {
 
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public fun connectOnCreate() {
        p("connectOnCreate")
    }
 
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public fun connectOnResume() {
        p("connectOnResume")
 
    }
}
 
// LifecycleObserver 是一个空接口
public interface LifecycleObserver {
 
}

上面过程做了三件事情：

• 实现LifecycleObserver的接口
• 编写要执行的方法
• 为每个方法添加注解，表示其执行的时机

@OnLifecycleEvent：运行注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

生命周期：Lifecycle.Event & State

// 生命周期Event
public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }
 
//5个对应的生命周期状态
 public enum State {
 
        DESTROYED,
 
        INITIALIZED,
 
        CREATED,
 
        STARTED,
 
        RESUMED;
 
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

通过Lifecycle.Event和State的查看，系统提供了Activity每个生命周期对应的Event，而Event有会有对应的State，此时 以大致猜想到上面的执行过程：

• 使用LifeEvent标记每个执行方法的Event
• 当活动状态改变时，系统会判断即将要改变成的状态
• 根据状态获取要执行的Event
• 从注册的Observer中获取标注为对应的Event，执行逻辑

生命周期的感知

LifecycleOwner

class LifeCyclerActivity : AppCompatActivity() {
  ...
 var myObserver = MyObserver(lifecycle, object : CallBack { // 创建LifecyclerObserver
            override fun update() {
          ...
            }
        })
        lifecycle.addObserver(myObserver) // 添加观察者
    }
}

从上面的使用情况看出，使用的活动需要调用getLifecycle（）方法，返回LifecycleRegistry，这里的getLifecycle（）方法其实是接口LifecycleOwner接口中的方法，

@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

此时LifecycleActivity虽然没有实现接口，因为他继承的AppCompatActivity继承了SupportActivity，而SupportActivity实现了接口

@RestrictTo(LIBRARY_GROUP)
public class SupportActivity extends Activity implements LifecycleOwner {
 
 private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); //创建
 
 @Override
    public Lifecycle getLifecycle() { // 重写方法返回LifecycleRegistry 
        return mLifecycleRegistry;
    }
 
}

SupportActivity除了执行上述操作外，在onCrate的方法中还有一句重要的代码，初始化了一个ReportFragment

protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ReportFragment.injectIfNeededIn(this);
    }
ReportFragment
public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";
 
    public static void injectIfNeededIn(Activity activity) { //初始化Fragment
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
 
  @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }
 
    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }
 
    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }
 
    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }
 
    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }
 
    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        mProcessListener = null;
    }
 
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }
 
        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
}

上面代码中做了两件事：

• 添加一个ReportFragment的实例
• 根据Fragment的每个生命周期的回调，调用dispatch（）处理回调事件

在dispatch（）方法中根据LifecyclerOwner和LifecyclerRegistryOwner实例分别处理，因为LifecyclerRegistryOwner也是继承LifecyclerOwner，而在我们SupportActivity中的getLifecycler（）中返回的是LifecycleRegistry，所以此处回调的都是LifecycleRegistry的handleLifecycleEvent；