学习背景

谷歌也是理解Android的碎片化给开发者带来的痛处,为了解决这种碎片化和规范开发,便推出了Jetpack 来统一江湖纷争.

官网定义:Jetpack 是一个由多个库组成的套件，可帮助开发者遵循最佳做法，减少样板代码并编写可在各种 Android 版本和设备中一致运行的代码，让开发者精力集中编写重要的代码。

jetpack优势

遵循最佳做法-Android Jetpack 组件采用最新的设计方法构建，具有向后兼容性，可以减少崩溃和内存泄露。
消除样板代码-Android Jetpack 可以管理各种繁琐的 Activity（如后台任务、导航和生命周期管理），以便您可以专注于打造出色的应用。
减少不一致-这些库可在各种 Android 版本和设备中以一致的方式运作，助您降低复杂性。

此内容来自官网介绍

Jetpack和AndroidX的关系

jetpack是开发组件的总称,AndroidX是组件的具体命名方式

Jetpack 结构

本文主要学习Arch部分其他的看时间进度吧

Arch 各部件简介

1,Lifecycle

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护

2, LiveData

支持共享资源、支持黏性事件的分发、不再需要手动处理生命周期、确保界面符合数据状态。

3,ViewModel

具备生命周期感知能力的数据存储组件

特性：1. 页面因配置变更导致的重启，此时数据不丢失。2. 可以实现跨页面 (跨 Activity) 的数据共享。

4,Room

Room 持久性库在 SQLite 的基础上提供了一个抽象层，让用户能够在充分利用 SQLite 的强大功能的同时，获享更强健的数据库访问机制。

5,Databinding

使用声明性格式将布局中的界面组件绑定到应用中的数据源。

6,Paging

使用 Paging 库，您可以更轻松地在应用的 RecyclerView 中妥善逐步加载数据。

7,Navigation

Navigation 是一个框架，用于在 Android 应用中的“目标”之间导航，不论目标是作为 Fragment、Activity 还是其他组件实现，该框架都会提供一致的 API。

8,WorkManager

使用 WorkManager API 可以轻松地调度那些必须可靠地运行的可延期异步任务。通过这些 API，您可以创建任务并提交给 WorkManager，以便在满足工作约束条件时运行。

学习参考

官网 Jetpack官网
官方github demo 链接
自己花一块钱白嫖的慕课网专栏专栏链接
刘舒望博客

接下来开始各个组件的学习吧

LifeCircle组件

LifeCircle定义

LifeCirlce 是具备宿主生命周期感觉能力的组件,它持有宿主的(Activity/Fragment)生命周期状态信息,并且允许其他观察者对宿主的生命周期进行监听,它是Jetpack库的核心基础.

LifeCirlce 简单使用(Activity中)

1,定义生命周期观察者
 class MYLifecycleObserver : LifecycleEventObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            Log.i("MainActivityTAG", event.name)
        }
    }

 2,activity中新建并注册观察者
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val myLifecycleObserver = MYLifecycleObserver()
        lifecycle.addObserver(myLifecycleObserver)
    }

效果

Fragment实现LifeCircle的方式

Lifecycle 是个抽象类  定义了基本方法和Lifecycle基本类型

public abstract class Lifecycle {
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    public abstract void removeObserver(@NonNull LifecycleObserver observer);
    ....省略  自己去看
   }

定义接口获取LifeCycle实例

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

LifecycleRegistry 继承LifeCycle

public class LifecycleRegistry extends Lifecycle {
}

Fragment实现LifecycleOwner

public class Fragment implements LifecycleOwner{
初始化LifeCircle实例
LifecycleRegistry mLifecycleRegistry;
public Fragment() {
        initLifecycle();
    }

private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
    }

 public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    
    void performCreate(Bundle savedInstanceState) {
    对Fragment事件进行分发
      mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    对Fragment事件进行分发
    void performStart() {
      mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    
    ...省略  自己看
}

LifeCycleOwner LifeCycle 和 LifecycleRegistry 关系

LifeCycleOwner

我们使用的Activity和Fragment 都是实现了该接口,声明两者都是具备生命周期的, 对外提供出一个LifeCycle对象,用户管理内部生命周期的分发等事务
LifeCycle

定义了生命期的枚举类型;定义了几个基本方法用于让子类进行实现
LifecycleRegistry

Lifecycle抽象类的子类,LifecycleOwner 生命周期分发等操作具体类,用于注册和反注册生命周期的关注者,并且将宿主的生命周期逐个分发给这些观察者

Activity 实现Lifecycle

Activity 实现Lifecycle是在Activity中添加ReportFragment,借助该Fragment汇报生命周期,目的是为了兼容不是继承于AppCompactActivity的场景,同时也是支持了自定义LifeOwner的场景这是很多面试官问到的问题

public class ComponentActivity implements LifecycleOwner{
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

public Lifecycle getLifecycle() {
       return mLifecycleRegistry;
   }
}

 @Override
   protected void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       ReportFragment.injectIfNeededIn(this);
   }

ReportFragment 具体实现

public class ReportFragment extends Fragment {
//在Activity的OnCreate中将该Fragment添加上
public static void injectIfNeededIn(Activity activity) {
       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);
      //分发Activity事件
       dispatch(Lifecycle.Event.ON_CREATE);
   }
   
    @Override
   public void onStart() {
       super.onStart();
      //分发Activity事件
       dispatch(Lifecycle.Event.ON_START);
   }
   //.....其他生命周期省略自己看
   
   //具体的分发实现方式
    private void dispatch(Lifecycle.Event event) {
       Activity activity = getActivity();
       if (activity instanceof LifecycleOwner) {
           Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
           if (lifecycle instanceof LifecycleRegistry) {
           //最终交给Activity的LifecycleRegistry进行分发处理
               ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
           }
       }
   }
}

LifecycleRegistry具体实现逻辑

在说具体的实现原理之前先看个有趣的现象,如果延迟一段时间注册声明周期观察者,会有什么现象呢

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //用handler延迟4s在进行声明周期的观察
        Handler().postDelayed(Runnable {
            val myLifecycleObserver = MYLifecycleObserver()
            lifecycle.addObserver(myLifecycleObserver)

        }, 4000);

    }

    class MYLifecycleObserver : LifecycleEventObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            Log.i("MainActivityTAG", event.name)
        }
    }
}

结果如果我们打开app后立马按下home键呢?

根据日志,我们可以分析到

延迟注册观察者,依旧会在添加注册观察者时,把宿主的生命周期分发给该观察者
延迟注册观察者后,对于相对的生命周期(onStart-onPause;onResume-OnStop),会相互"抵消",只保留未被"抵消"的生命周期分发给该观察者

一切还得从 addObserver()方法开始说

#LifecycleRegistry类 精简后方法
@Override
    public void addObserver(@NonNull LifecycleObserver observer) {
    	//1,获取当前宿主的生命周期mState 进行比对和初始化
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        //2,将observer 封装成ObserverWithState对象
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        //3,添加到 mObserverMap 的map中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
		//4,计算需要给该观察者所分发的目标生命周期
        State targetState = calculateTargetState(observer);
     	//5,通过循环比对和分发将之前错过的生命周期分发给该观察者
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            targetState = calculateTargetState(observer);
        }

    }

1. 疑问一:mState怎么来的?

# LifecycleRegistry类

private State mState;
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        //构造方法初始化
        mState = INITIALIZED;
    }
    
    //具体的分发生命周期方法
    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
        State next = getStateAfter(event);
        moveToState(next);
    }
	//具体的mState赋值方法
    private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
    }

那么到底是谁调用了 handleLifecycleEvent()方法呢?

还记得Fragment和Activity怎么实现Lifecycle的吗?没错就是他们.

再看看getStateAfter()怎么算出生命周期的呢

  static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

在我们延迟4s注册观察者的时候(不按Home键),Activity分别经历了 OnCreate()->onStart()->OnResume(),那么mState就应该是INITIALIZED->CREATED->STARTED->RESUMED

得出结论: mState当前是RESUMED,

从而得到了第一步的initialState

State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED; initialState=INITIALIZED;

疑问二:ObserverWithState 是个神马东西?

ObserverWithState 内部类

 static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }

其实就是对 LifecycleEventObserver的封装

疑问三:mObserverMap 干啥的?

从后面的代码可以知道作比对的,之后再说吧

疑问四:calculateTargetState() 怎么算出需要给观察者的目标生命周期的?

这个源码比较琐碎一点,自己看的话也可以看懂,最终实现就是使用的 Lifecycle 的枚举 State排序compareTo()进而对mState和initialState进行比较实现,枚举是根据定义的先后顺序进行排序的

#Lifecycle类
public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }

从疑问一中我们知道 mState 是RESUMED ;initialState是INITIALIZED;

结论 targetState 就是 mState也就是RESUMED

疑问五:while循环里干了点啥?

先把代码搬过来
 while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            targetState = calculateTargetState(observer);
        }

我们知道statefulObserver.mState被初始化为 INITIALIZED而targetState是RESUMED,所以条件成立进入循环.

细心的你应该发现了statefulObserver分发时还有个upEvent()方法

#LifecycleRegistry类
 private static Event upEvent(State state) {
        switch (state) {
            case INITIALIZED:
            case DESTROYED:
                return ON_CREATE;
            case CREATED:
                return ON_START;
            case STARTED:
                return ON_RESUME;
            case RESUMED:
                throw new IllegalArgumentException();
        }
        throw new IllegalArgumentException("Unexpected state value " + state);
    }

所以所以 while循环里statefulObserver.dispatchEvent 分发的顺序是

初始条件 state=INITIALIZED

ON_CREATE->ON_START->ON_RESUME,在赋值到ON_RESUME后跳出while循环

所以在我们延迟4s后addObserver()的时候依旧能感知到Activity的生命周期变化. 那么为什么我们立马按下Home键后只有OnCreate呢?

打开app后立马按下Home键 Activity经历了 OnCreate()->OnStart()-OnResume()-OnPause()->OnStop()
还记得我们的mState怎么来的吗?通过Activity调用handleLifecycleEvent()-getStateAfter()方法获得的

再贴一下代码

 static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }

Activity调用完OnStop()之后 mState 就变成了CREATED

那么初始化的initialState 还是 INITIALIZED

在while循环中,根据upEvent()方法INITIALIZED直接就是ON_CREATE

我们知道 Lifecycle类枚举

public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        }

INITIALIZED之后就是 CREATED

while循环中只循环了一次便跳出了循环,所以观察者只感知到了OnCreate

Jetpack 学习一:背景介绍和LifeCircle组件