JetPack

JetPack.jpg

这里讲述一下 JetPack 常用的几个库的特点以及坑。

Lifecycles

Lifecycles 提供了可用于构建生命周期感知型组件的类和接口 - 这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。

Lifecycle

LifeCycle 存储了有关组件(Fragment 或者 Activity)的生命周期状态信息，并且允许其他对象观察。

通过 event 去更新 state，event 和 state 如下：

public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY
}

/**
 * Lifecycle states. You can consider the states as the nodes in a graph and
 * {@link Event}s as the edges between these nodes.
 */
@SuppressWarnings("WeakerAccess")
public enum State {
    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
}

LifeCycleOwner

返回一个 LifeCycle 对象，如果这个类是一个有生命周期的组件，需要实现这个接口

LifecycleRegister

一个 LifeCycle 的实现类,主要通过以下一些代码，更新 LifeCycle 的 State

//LifecycleRegister.handleLifecycleEvent() 方法
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

也就是说，在 Fragment 中有这样的方法：

//androidx Fragment.java 源码中
void performResume() {
   //省略一些代码
  //这里会调用 LifeCycleRegistry 的 handleLifecycleEvent() 
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    if (mView != null) {
        mViewLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }
}

参考

使用生命周期感知型组件处理生命周期

LiveData

根据 LiveData 的文档介绍，LiveData 使用如下：

创建 LiveData 实例以存储某种类型的数据。这通常在 ViewModel 类中完成。
创建可定义 onChanged() 方法的 Observer 对象，该方法可以控制当 LiveData 对象存储的数据更改时会发生什么。通常情况下，您可以在界面控制器（如 Activity 或 Fragment）中创建 Observer 对象。
使用 [observe()](https://developer.android.com/reference/androidx/lifecycle/LiveData#observe(android.arch.lifecycle.LifecycleOwner, android.arch.lifecycle.Observer)) 方法将 Observer 对象附加到 LiveData 对象。observe() 方法会采用 LifecycleOwner 对象。这样会使 Observer 对象订阅 LiveData 对象，以使其收到有关更改的通知。通常情况下，您可以在界面控制器（如 Activity 或 Fragment）中附加 Observer 对象。

其实，总的来说，就是 LiveData，有两个特点

在根据 observe() 方法传入的

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    //判断是否主线程
    assertMainThread("observe");
    //如果 LifeCycle 组件已经销毁，则不发生任何操作
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    //封装 LifecycleBoundObserver 观察类，如果 state == Destory，则会自动 remove observer
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;
    }
    //根据传入的Lifecycle 添加观察者
    owner.getLifecycle().addObserver(wrapper);
}

这个方法只能执行在主线程

这里的代码还是要和 LifeCycle 结合起来理解

ViewModel

ViewModel 提出，是为了以下几个问题

分离界面渲染和数据获取的只能
根据界面的生命周期，去管理数据（包括初始化，复用等）

我们通过 ViewModelProvider.of() 方法，获取不同的 ViewModule，会根据传入的 Fragment/Activity 去获取不同的 ViewModule，of() 方法返回一个 ViewModelProvider。

//ViewModuleProvider.of() 方法
public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) {
    Application application = checkApplication(checkActivity(fragment));
    if (factory == null) {
        factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
    }
     //这里会获取 fragment 的 viewModelStore()
    return new ViewModelProvider(fragment.getViewModelStore(), factory);
}

ViewModule 的 onClear() 方法会在 Fragment/Actiivty 的 onDestory() 去销毁数据，如下

//Fragment.java androidx 中
public void onDestroy() {
    mCalled = true;
    FragmentActivity activity = getActivity();
    boolean isChangingConfigurations = activity != null && activity.isChangingConfigurations();
    if (mViewModelStore != null && !isChangingConfigurations) {
        mViewModelStore.clear();
    }
}
// ViewModelStore.java 中
    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.onCleared();
        }
        mMap.clear();
    }