「Jetpack - Lifecycle梳理」

最新推荐文章于 2024-03-30 18:52:54 发布

安卓老猴子

最新推荐文章于 2024-03-30 18:52:54 发布

阅读量152

点赞数

分类专栏：程序员 Android kotlin 文章标签： android android studio java

本文链接：https://blog.csdn.net/star_nwe/article/details/123122522

版权

Android 同时被 3 个专栏收录

96 篇文章 6 订阅

订阅专栏

程序员

62 篇文章 1 订阅

订阅专栏

kotlin

19 篇文章 1 订阅

订阅专栏

「Jetpack - Lifecycle梳理」

一、写在前面

谷歌推出Jetpack系列已经有一段时间了，作为AAC(Android Architecture Components)架构组件基础，使开发的过程越来越规范化，遵循谷歌推荐的最佳做法不仅使App更加健壮；体验更优。代码层面更加简洁(Jetpack内部帮我们处理了很多)优雅，消除了冗余的样板代码。

关于Jetpack系列的解析，大佬们输出了很多优秀的文章。学到了很多，这里还是自己系统的梳理一遍，构建自己的知识体系，包括LiveData、ViewModel、Room、WorkManager、Paging3、Compose等等。

二、Lifecycle是什么？

官方定义

用于生命周期感应型组件的构建，可以根据Fragment、Activity的生命周期状态而自动调整自身的行为、操作

Lifecycle是一个抽象类，用于存储有关组件(Activity、Fragment)的生命周期状态的信息，并允许其他对象观察此状态。
使用两种主要的枚举跟踪相关组件的生命周期状态

事件Events

从框架和Lifecycle类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

状态States

由 Lifecycle 对象跟踪的组件的当前状态。
官网的结构图

三、使用依赖

(早期的依赖已经弃用了)

lifecycle-extensions 中的 API 已弃用。您可以为特定 Lifecycle 工件添加所需的依赖项。

添加相关组件的依赖

dependencies {
  val lifecycle_version = "2.4.0"
  //without ViewModel or LiveData
  implementation("androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version")
  //ViewModel(可选的)
  implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version")
  // LiveData(可选的)
  implementation("androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version")
}

一般的使用Lifecycle都会搭配ViewModel、LiveData一起使用，构建数据驱动UI型应用，可以说Lifecycle作为Jetpack的基石，循序渐进的去掌握有助于理解深刻。

四、生命周期的管理

生命周期的管理很重要

Android中的内存泄漏问题很大一部分来源于对生命周期的管理不当，资源在本应该释放的时候并没有得到释放。导致生命周期短的组件持有了生命周期长的组件最终导致内存泄漏，应用Crash。自定义View包含动画时，onPause时动画的暂停，handler回收消息的移除等这些都与生命周期关联。

官方的使用Demo(获取定位信息)

在App启动时开启获得定位的信息对应onStart()，而在**onStop()**对资源进行释放。

internal class MyLocationListener(
  private val context: Context,
  private val callback: (Location) -> Unit
) {
  fun start() {
    //连接到定位服务器，connect to system location service
  }
  fun stop() {
    //断开与服务器的链接，disconnect from system location service
  }
}

class MyActivity : AppCompatActivity() {
  private lateinit var myLocationListener: MyLocationListener
  override fun onCreate(...) {
    myLocationListener = MyLocationListener(this) { location ->
    //update ui
   }
  }
  
  public override fun onStart() {
    super.onStart()
    myLocationListener.start()
  }
  
  public override fun onStop() {
    super.onStop()
    myLocationListener.stop()
  }
}

Demo的实现很简单，但是具有代表性，比较符合我们以往的**“开发习惯”**，虽然做到了对生命周期的管理，在合适的做到了资源的使用与释放，但是其实是存在问题的。

1.太过于理想化-无论是在onStart()还是在onStop()，我们都是基于App的生命能够正常的执行的前提之下，并没有考虑到异常的情况下如何管理资源；建立在假设它们能顺利执行，对组件MyLocationListener生命周期的管理太过于脆弱。

2.一个完整的App肯定包含的组件很多，忽略了其他组件的条件竞争关系，其次随之系统的不断迭代，方法的叠加，项目会不容易管理就单生命周期这一项工作就很难处理完美。

3.思考-Glide都不陌生，在调用的时候只需要传入this，内部维护了一套生命周期管理流程，那么如果MyLocationListener绑定到MyActivity之上这个问题不就解决了嘛？Lifecycle解决了这个问题。

五、Lifecycle源码实现

1.Lifecycle

Defines an object that has an Android Lifecycle. Fragment and FragmentActivity classes implement LifecycleOwner interface which has the getLifecycle method to access the Lifecycle. You can also implement LifecycleOwner in your own classes.

Lifecycle.Event.ON_CREATE, Lifecycle.Event.ON_START, Lifecycle.Event.ON_RESUME events in this class are dispatched after the LifecycleOwner’s related method returns. Lifecycle.Event.ON_PAUSE, Lifecycle.Event.ON_STOP, Lifecycle.Event.ON_DESTROY events in this class are dispatched before the LifecycleOwner’s related method is called. For instance, Lifecycle.Event.ON_START will be dispatched after onStart returns, Lifecycle.Event.ON_STOP will be dispatched before onStop is called. This gives you certain guarantees on which state the owner is in.

To observe lifecycle events call addObserver(LifecycleObserver) passing an object that implements either DefaultLifecycleObserver or LifecycleEventObserver.

简单的概括一下：定义一个具有生命周期的对象。Fragment与FragmentActivity实现了LifecycleOwner接口，而接口中方法getLifecycle可以获得Lifecycle引用，开发者可以通过实现LifecycleOwner接口来自定义自己的生命周期组件，通过类中状态，如Lifecycle.Event.ON_START等完成对应的匹配，要观察生命周期的事件那么需要通过添加生命周期的观察者addObserver(LifecycleObserver)传递的是DefaultLifecycleObserver或者LifecycleEventObserver的实现类。

注释中解释的很清楚，Lifecycle相当于一个中转站，有什么作用呢？管理生命周期的组件，无论是系统的Fragment、Activity或者是开发自定义的组件(实现了LifecycleOwner接口)。当状态流转时，“中转站”内的组件的生命周期状态应该保持对应。看看源码中几个重要的方法：

public abstract class Lifecycle {
  @MainThread
  public abstract void addObserver(@NonNull LifecycleObserver observer);
  
  @MainThread
  public abstract void removeObserver(@NonNull LifecycleObserver observer);
  
  @MainThread
  @NonNull
  public abstract State getCurrentState();
  
  public enum Event {
    ON_CREATE,ON_START,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY;
    
    @Nullable
    public static Event downFrom(@NonNull State state) {
      switch (state) {
          case CREATED:
          	return ON_DESTROY;
          case STARTED:
          	return ON_STOP;
          case RESUMED:
          	return ON_PAUSE;
      }
    }
    //......
  }
  public enum State {
    DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED;
    public boolean isAtLeast(@NonNull State state) {
      return compareTo(state) >= 0;
    }
  }
}

由之前给出的图，Lifecycle中定义了状态State与之对应的事件Event，将绑定的生命周期组件添加到中转站之中，随着状态主体LifecycleOwner状态的改变而获得对应的状态-addObserver()；同样的有添加就有移除操作removeObserver()。也就是说Owner的状态发生改变需要搭配LifecycleObserver才能被转发下去，典型的观察与订阅，首先不看LifecycleObserver具体实现。Lifecycle作为抽象类，看看其具体实现类。
LifecycleRegistry实现类

Lifecycle的具体实现类，用来处理多个LifecycleObserver的状态，同时除了Fragment与Activity以外，还可以处理自定义的生命周期组件。看看是如何处理生命周期事件传递的。

public class LifecycleRegistry extends Lifecycle {
  //通过一个FastSafeIterableMap将观察者连同状态一起保存起来，保存调用addObserver()后存储的对象，这个map
  //系统自定义的结构，线程不安全，但是提供了在遍历时修改的功能。
  private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = 
    new FastSafeIterableMap<>();
  //当前的状态
  private State mState;
  //若引用持用了生命周期的组件
  private final WeakReference<LifecycleOwner> mLifecycleOwner;
  
  private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
    mLifecycleOwner = new WeakReference<>(provider);
    mState = INITIALIZED;
    mEnforceMainThread = enforceMainThread;
  }
  //设置当前状态
  @MainThread
  public void setCurrentState(@NonNull State state) {
    moveToState(state);
  }
  //处理生命周期事件
  public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    moveToState(event.getTargetState());
  }
  
  private void moveToState(State next) {
    if (mState == next) {
      return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
      mNewEventOccurred = true;
      return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
  }
  
  private boolean isSynced() {
    if (mObserverMap.size() == 0) {
            return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
  }
  
  private void sync() {
    //省略判空
    while (!isSynced()) {
      mNewEventOccurred = false;
      if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
        backwardPass(lifecycleOwner);
      }
       Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
         if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
      }
    }
    mNewEventOccurred = false;
  }
  
  private void forwardPass(LifecycleOwner lifecycleOwner) {
    //....
    observer.dispatchEvent(lifecycleOwner, event);
    //....
  }
  
  private void backwardPass(LifecycleOwner lifecycleOwner) {
    //...
    observer.dispatchEvent(lifecycleOwner, event);
    //...
  }
  
  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 = event.getTargetState();
      mState = min(mState, newState);
      mLifecycleObserver.onStateChanged(owner, event);
      mState = newState;
    }
  }
}

1.在构造函数中，可以看到提供了一个类型为LifecycleOwner的provider，这个很好理解，结合方法addObserver()，一个宿主Owner组件中可以包含多个依附的组件，依赖于Owner的生命周期。只需要观察这个Owner的状态变更作出自身的操作即可，也即是添加观察者Observer(LifecycleObserver)。

2.在方法sync()中，首先对目标状态与当前状态作了比较，方法isSynced()，判断当前状态与目标是否相等，并且最新状态与最旧的状态是否一致，如果都满足，那么就不会在处理。

3.while(!isSynced())中，也即是状态同步，将当前状态分别与最新、最旧的状态比较保证观察者的状态都是一致的，如果当前状态比最旧的状态小那么走backwardPass()，反之当前状态比最新的状态大走forwardPass()。以Activity为例，从onStart到onResume经历的事件是很短暂的，这也是为什么取当前状态的下移状态。

//Returns the Lifecycle.Event that will be reported by a Lifecycle leaving the specified //Lifecycle.State to a higher state, or null if there is no valid event that can move up //from the given state.
public static Event upFrom(@NonNull State state) {
  switch (state) {
     case INITIALIZED:
         return ON_CREATE;
     case CREATED:
         return ON_START;
     case STARTED:
         return ON_RESUME;
     default:
         return null;
  }
}

dispatchEvent

无论是backwardPass还是forwardPass，最终都会执行到dispatchEvent方法，getTargetState通过计算对应的状态，通知到所有的观察者。而继承自LifecycleObserver的LifecycleEventObserver接口方法onStateChanged就完成了状态的更新操作。

2.LifecycleOwner

A class that has an Android lifecycle. These events can be used by custom components to handle lifecycle changes without implementing any code inside the Activity or the Fragment.

具有Android生命周期的类，通过事件自定义的组件可以处理生命周期的变化而无需在Activity或Fragment中实现相关代码。

LifecycleOwner是一个接口，仅仅包含了一个方法。返回“生命周期”Lifecycle。

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

既然是接口，那么看看实现类，以AppCompatActivity为例，而其完整的继承链路为：

AppCompatActivity -> FragmentActivity -> ComponentActivity

直接查看ComponentActivity的实现细节，看看究竟是如何管理生命周期的。

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner... {
  
  private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  
  @NonNull
  @Override
  public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
  }
  
  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
     // Restore the Saved State first so that it is available to
     // OnContextAvailableListener instances
     mSavedStateRegistryController.performRestore(savedInstanceState);
     mContextAwareHelper.dispatchOnContextAvailable(this);
     super.onCreate(savedInstanceState);
     //ReportFragment注入
     ReportFragment.injectIfNeededIn(this);
     if (mContentLayoutId != 0) {
       setContentView(mContentLayoutId);
     }
   }
}

在ComponentActivity中仅仅只有一个生命周期方法onCreate()作了处理，而其他的生命周期方法并未有具体实现。那又是怎么管理生命周期的呢？跟预期显然是不符合的，但是注意到这个ReportFragment这个的注入。似曾相识，如果熟悉Glide图片加载库对生命周期的管理-无布局的Fragment注入。这里其实也做了同样的事情。看看是不是使用相似的方法来管理生命周期。

ReportFragment

ReportFragment关键代码实现。

public class ReportFragment extends Fragment {
  public static void injectIfNeededIn(Activity activity) {
    if (Build.VERSION.SDK_INT >= 29) {
      activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks()));
    }
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
      manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
      manager.executePendingTransactions();
    }
  }
  
  //....
  static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
    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);
       }
     }
  }
	
  @Override
  public void onStart() {
    super.onStart();
    dispatchStart(mProcessListener);
    dispatch(Lifecycle.Event.ON_START);
  }
  //.....
}

关键方法dispatch()，ReportFragment通过注入的方法，依附到Activity之上，根据Fragment特性，此时Fragment的生命周期就与宿主Activity绑定了。对宿主Activity的生命周期的管理自然的就后移到了Fragment之上也就是ReportFragment中。而最终都回调到了**dispatch()**之中，到这里就完成了分发的工作，那么由谁来真正处理呢？

((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);

之前提到接口Lifecycle的实现类LifecycleRegistry则是完成了对生命周期的处理。

总结一下：

1.ReportFragment通过注入的方式依附到Activity之上，将自身的生命周期与Activity绑定，也即是将生命周期的管理后移。

2.通过dispatch()来分发生命周期事件。而最终处理生命周期事件的类则为Lifecycle的实现类-LifecycleRegistry

自定义生命周期感知类

官方比较推荐的做法是实现DefaultLifecycleObserver接口

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        //do something
    }

    override fun onPause(owner: LifecycleOwner) {
        //do something
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

当然也可以配合LifecycleRegistry与LifecycleOwner实现更加细致的功能需求

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

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

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

六、文档

Jetpack-Lifecycle

Lifecycle

Modern Android Development

fecycle](https://link.juejin.cn/?target=https%3A%2F%2Fdeveloper.android.com%2Fjetpack%2Fandroidx%2Freleases%2Flifecycle%3Fhl%3Dzh-cn%23kts “https://developer.android.com/jetpack/androidx/releases/lifecycle?hl=zh-cn#kts”)

Modern Android Development

最后

分享给大家一份面试题合集。

下面的题目都是在Android交流群大家在面试时遇到的，如果大家有好的题目或者好的见解欢迎分享，楼主将长期维护此帖。
参考解析：郭霖、鸿洋、玉刚、极客时间、腾讯课堂…

内容特点：条理清晰，含图像化表示更加易懂。

内容概要：包括 Handler、Activity相关、Fragment、service、布局优化、AsyncTask相关
、Android 事件分发机制、 Binder、Android 高级必备：AMS,WMS,PMS、Glide、 Android 组件化与插件化等面试题和技术栈！

Handler 相关知识，面试必问！

常问的点：
Handler Looper Message 关系是什么？
Messagequeue 的数据结构是什么？为什么要用这个数据结构？
如何在子线程中创建 Handler?
Handler post 方法原理？
Android消息机制的原理及源码解析
Android Handler 消息机制

Activity 相关

启动模式以及使用场景?
onNewIntent()和onConfigurationChanged()
onSaveInstanceState()和onRestoreInstanceState()
Activity 到底是如何启动的
启动模式以及使用场景
onSaveInstanceState以及onRestoreInstanceState使用
onConfigurationChanged使用以及问题解决
Activity 启动流程解析

Fragment

Fragment 生命周期和 Activity 对比
Fragment 之间如何进行通信
Fragment的startActivityForResult
Fragment重叠问题
Fragment 初探
Fragment 重叠，如何通信
Fragment生命周期

Service 相关

进程保活
Service的运行线程（生命周期方法全部在主线程）
Service启动方式以及如何停止
ServiceConnection里面的回调方法运行在哪个线程？
startService 和 bingService区别
进程保活一般套路
关于进程保活你需要知道的一切

Android布局优化之ViewStub、include、merge

什么情况下使用 ViewStub、include、merge？
他们的原理是什么？
ViewStub、include、merge概念解析
Android布局优化之ViewStub、include、merge使用与源码分析

BroadcastReceiver 相关

注册方式，优先级
广播类型，区别
广播的使用场景，原理
Android广播动态静态注册
常见使用以及流程解析
广播源码解析

AsyncTask相关

AsyncTask是串行还是并行执行？
AsyncTask随着安卓版本的变迁
AsyncTask完全解析
串行还是并行

Android 事件分发机制

onTouch和onTouchEvent区别，调用顺序
dispatchTouchEvent， onTouchEvent， onInterceptTouchEvent 方法顺序以及使用场景
滑动冲突，如何解决
事件分发机制
事件分发解析
dispatchTouchEvent， onTouchEvent， onInterceptTouchEvent方法的使用场景解析

Android View 绘制流程

简述 View 绘制流程
onMeasure， onlayout， ondraw方法中需要注意的点
如何进行自定义 View
view 重绘机制

Android LayoutInflater原理分析，带你一步步深入了解View(一)
Android视图状态及重绘流程分析，带你一步步深入了解View(二)
Android视图状态及重绘流程分析，带你一步步深入了解View(三)
Android自定义View的实现方法，带你一步步深入了解View(四)

Android Window、Activity、DecorView以及ViewRoot

Window、Activity、DecorView以及ViewRoot之间的关系

Android 的核心 Binder 多进程 AIDL

常见的 IPC 机制以及使用场景
为什么安卓要用 binder 进行跨进程传输
多进程带来的问题

AIDL 使用浅析
binder 原理解析
binder 最底层解析
多进程通信方式以及带来的问题
多进程通信方式对比

Android 高级必备：AMS,WMS,PMS

AMS,WMS,PMS 创建过程

AMS,WMS,PMS全解析
AMS启动流程
WindowManagerService启动过程解析
PMS 启动流程解析

Android ANR

为什么会发生 ANR？
如何定位 ANR？
如何避免 ANR？
什么是 ANR
如何避免以及分析方法
Android 性能优化之 ANR 详解

Android 内存相关

注意：内存泄漏和内存溢出是 2 个概念

什么情况下会内存泄漏？
如何防止内存泄漏？

内存泄漏和溢出的区别
OOM 概念以及安卓内存管理机制
内存泄漏的可能性
防止内存泄漏的方法

Android 屏幕适配

屏幕适配相关名词解析
现在流行的屏幕适配方式

屏幕适配名词以及概念解析
今日头条技术适配方案

Android 缓存机制

LruCache使用极其原理

Android缓存机制
LruCache使用极其原理述

Android 性能优化

如何进行内存 cpu 耗电的定位以及优化
性能优化经常使用的方法
如何避免 UI 卡顿

性能优化全解析，工具使用
性能优化最佳实践
知乎高赞文章

Android MVC、MVP、MVVM

好几种我该选择哪个？优劣点

任玉刚的文章：设计模式选择

Android Gradle 知识

这俩篇官方文章基础的够用了
必须贴一下官方文档：配置构建
 Gradle 提示与诀窍

Gradle插件了解就好
Gradle 自定义插件方式
全面理解Gradle - 执行时序

Gradle系列一
Gradle系列二
Gradle系列三

RxJava

使用过程，特点，原理解析
RxJava 名词以及如何使用
Rxjava 观察者模式原理解析
Rxjava订阅流程，线程切换，源码分析系列

OKHTTP 和 Retrofit

OKHTTP完整解析
Retrofit使用流程，机制详解
从 HTTP 到 Retrofit
Retrofit是如何工作的

最流行图片加载库： Glide

郭神系列 Glide 分析
Android图片加载框架最全解析（一），Glide的基本用法
Android图片加载框架最全解析（二），从源码的角度理解Glide的执行流程
Android图片加载框架最全解析（三），深入探究Glide的缓存机制
Android图片加载框架最全解析（四），玩转Glide的回调与监听
Android图片加载框架最全解析（五），Glide强大的图片变换功能
Android图片加载框架最全解析（六），探究Glide的自定义模块功能
Android图片加载框架最全解析（七），实现带进度的Glide图片加载功能
Android图片加载框架最全解析（八），带你全面了解Glide 4的用法

Android 组件化与插件化

为什么要用组件化？
组件之间如何通信？
组件之间如何跳转？
Android 插件化和热修复知识梳理
为什么要用组件化

Android彻底组件化方案实践
Android彻底组件化demo发布
Android彻底组件化-代码和资源隔离
Android彻底组件化—UI跳转升级改造
Android彻底组件化—如何使用Arouter

插件化框架历史
深入理解Android插件化技术
Android 插件化和热修复知识梳理

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

好啦，这份资料就给大家介绍到这了，有需要详细文档的小伙伴，可以微信扫下方二维码免费领取哈~

安卓老猴子

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
「Jetpack - Lifecycle梳理」

「Jetpack - Lifecycle梳理」一、写在前面谷歌推出Jetpack系列已经有一段时间了，作为AAC(Android Architecture Components)架构组件基础，使开发的过程越来越规范化，遵循谷歌推荐的最佳做法不仅使App更加健壮；体验更优。代码层面更加简洁(Jetpack内部帮我们处理了很多)优雅，消除了冗余的样板代码。关于Jetpack系列的解析，大佬们输出了很多优秀的文章。学到了很多，这里还是自己系统的梳理一遍，构建自己的知识体系，包括LiveData、ViewM
复制链接

扫一扫