Android 架构组件

在2017年谷歌推出Android新的架构组件-一组可以帮助开发者设计强大的,可测试的和可维护的应用程序组件库。

下面我将重点介绍以下几个实用组件:

LifeCycle 

LiveData

ViewModel

官网地址:

https://developer.android.com/topic/libraries/architecture/

-----------------------------------------------------

生命周期感知组件-LifeCycle

1、LifeCycle能够做什么

支持生命周期的组件执行操作以响应另一个组件(例如Activity和Fragment)的生命周期状态更改。

这些组件可帮助你生成组织性更好,并且通常重量更轻的代码,这些代码更易于维护。

2、为什么需要Lifecycle组件

常见的模式是在Activity和Fragment的生命周期方法中实现依赖组件的操作。

但是,这种模式导致代码的组织不良以及错误泛滥,一堆看不懂的代码。

通过使用生命周期感知组件,你可以将相关组件的代码从生命周期方法中移出并移入组件本身。

下面来看个例子:

假如需要在生命周期中处理某些事情,可能会有两种方式,一、直接在Activity或者Fragment中的生命周期方法中写代码逻辑;二、写一个接口,定义类似生命周期的方法,在Activity或Fragment中调用相应的方法将逻辑剥离,不过也离不开Activity或Fragment。

/** * Main Presenter */
public class MainPresenter implements IPresenter {    

    public MainPresenter(Context context){  }    

    @Override    
    public void onResume() {    }    

    @Override    
    public void onStop() {    }    

}
public interface IPresenter {
    void onResume();
    void onStop();
}
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private IPresenter mPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate: ");
        setContentView(R.layout.activity_main);
        mPresenter = new MainPresenter(this);
    }
    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "onResume: ");
        mPresenter.onResume();
    }
    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "onStop: ");
        mPresenter.onStop();
    }
}

IPresenter中定义和生命周期相关的几个方法,然后在MainActivity中调用对应的方法。这样做会有个问题:在MainActivity中的每个生命周期方法中都要调用一次IPresenter中的接口。那有没有更好的办法呢,这时候LifeCycle就该上场了:

public class MainPresenter implements IPresenter {
    private static final String TAG = "MainPresenter";
    public MainPresenter(Context context){
    }
    @Override
    public void onCreate(LifecycleOwner owner) {
        Log.d(TAG, "onCreate: ");
    }
    @Override
    public void onStart(LifecycleOwner owner) {
        Log.d(TAG, "onStart: ");
    }
    @Override
    public void onResume(LifecycleOwner owner) {
        Log.d(TAG, "onResume: ");
    }
    @Override
    public void onPause(LifecycleOwner owner) {
        Log.d(TAG, "onPause: ");
    }
    @Override
    public void onStop(LifecycleOwner owner) {
        Log.d(TAG, "onStop: ");
    }
    @Override
    public void onDestroy(LifecycleOwner owner) {
        Log.d(TAG, "onDestroy: ");
    }
}
public interface IPresenter extends DefaultLifecycleObserver{

}
public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";
    private IPresenter mPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate: ");
        setContentView(R.layout.activity_main);
        mPresenter = new MainPresenter(this);
        getLifecycle().addObserver(mPresenter);
    }
}

代码是不是很简单,尤其是Activity。

IPrestener 接口继承 DefaultLifecycleObserver 接口,然后 MainPresenter 实现 IPresenter 接口,在 MainPresenter 中,可以把 DefaultLifecycleObserver 中生命周期的方法全实现,也可以选择实现其中几个,比如你只关心 MainActivity 的 onCreate()  和 onDestroy() ,那么你就可以在 MainPresenter 中实现 onCreate() 和 onDestroy() 方法。借助实现 DefaultLifecycleObserver 接口可以让我们少写很多代码。

到这里大家可能就非常想知道Lifecycle组件实现的原理是什么?那么接着向下看。

3、LifeCycle实现原理

先来看一张图:

我们以V4包中的 Fragment(AppCompatActivity类似)为例,看下 Fragment 和 LifecycleOwner、LifecycleObserver、Lifecycle 之间的类关系图。

  • Lifecycle 组件成员Lifecycle被定义成了抽象类,LifecycleOwner、LifecycleObserver 被定义成了接口;

  • Fragment 实现了 LifecycleOwner 接口,该只有一个返回 Lifecycle 对象的方法 getLifecyle();

  • Fragment 中 getLifecycle() 方法返回的是继承了抽象类 Lifecycle 的 LifecycleRegistry。

  • LifecycleRegistry 中定义嵌套类 ObserverWithState,该类持有 GenericLifecycleObserver 对象,而 GenericLifecycleObserver 是继承了 LifecycleObserver 的接口。

再来看一张时序图:

  • 我们在 Fragment(AppCompatActivity也一样)中调用 getLifecycle() 方法得到 LifecycleRegistry 对象,然后调用 addObserver() 方法并将实现了 LifecycleObserver 接口的对象作为参数传进去。这样一个过程就完成了注册监听的过程。

  • 后续就是 Fragment 生命周期变化时,通知 LifecycleObserver 的过程: Fragment的performXXX()、onXXX() 方法; LifecycleRegistry 的 handleLifecycleEvent() 方法; LifecycleObserver 的 onXXX() 方法。

  • 如果你细心点看上面的时序图,你会发现 Fragment 中 performCreate()、performStart()、performResume() 会先调用自身的 onXXX() 方法,然后再调用 LifecycleRegistry 的 handleLifecycleEvent() 方法;而在 performPause()、performStop()、performDestroy() 中会先 LifecycleRegistry 的handleLifecycleEvent() 方法 ,然后调用自身的 onXXX() 方法。

可以看看Fragment源码

4、细节

我们要做的内容主要是实现 LifecycleObserver 接口,然后通过实现了 LifecycleOwner 接口的对象进行注册,以监听其生命周期,后续就是坐等通知了。

5、实现LifecycleObserver接口

从上面的类关系图,我们可以看到有三个接口 GenericLifecycleObserver、FullLifecycleObserver、DefaultLifecycleObserver 都直接或者间接继承了 LifecycleObserver。然而 GenericLifecycleObserver 是隐藏的,我们用不了。那我们该怎么实现 LifecycleObserver 接口呢,有两种方式:

  • 实现 DefaultLifecycleObserver 接口,然后重写里面生命周期方法(如上);

  • 直接实现 LifecycleObserver 接口,然后通过注解的方式来接收生命周期的变化;

class MyLocationListener implements LifecycleObserver {
    private boolean enabled = false;
    public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {

    }
}

对于这两种形式,Lifecycle.java 文档中是建议使用第一种方式,因为文档中说明了, 随着Java8成为主流,注解的方式会被弃用。

6、添加观察者

实现 LifecycleOwner 后,最后一步,我们直接看添加观察者( addObserver(实现 LifecycleObserver 的观察者class) )

生命周期感知组件的最佳实践

  • 尽可能保持你的UI控制器(Activity或Fragment)尽可能精简。他们不应该试图获取他们自己的数据;相反,使用 ViewModel  来做到这一点,并观察一个  LiveData  对象,以反映到视图的变化。

  • 尝试编写数据驱动的用户界面,其中你的用户界面控制器的职责是在数据更改时更新视图,或将用户操作通知给用户 ViewModel

  • 把你的数据逻辑放在你的 ViewModel class 上。 ViewModel  应该充当你的UI控制器和其他应用程序之间的连接器。但要小心, ViewModel  不是用来获取数据的(例如,从网络)。相反, ViewModel  应该调用适当的组件来获取数据,然后将结果提供给UI控制器。

  • 使用 Data Binding  在视图和UI控制器之间保持干净的界面。这使你可以使你的视图更具说明性,并最大限度地减少需要在 Activity 和 Fragment 中编写的更新代码。如果你喜欢用 Java 编程语言来做到这一点,可以使用像 Butter Knife 这样的库来避免样板代码并且有更好的抽象。

  • 如果你的UI很复杂,请考虑创建一个  presenter 类来处理UI修改。这可能是一项艰巨的任务,但它可以使你的UI组件更易于测试。

  • 避免在你的 ViewModel 中引用一个 View 或 Activity 上下文。如果 ViewModel比 Activity 活的更长(在配置更改的情况下),Activity 就会发生泄漏并且垃圾收集器无法妥善处理。

-----------------------------------------------------

LiveData

1、LiveData是什么?

LiveData 是一个可观察的数据持有者类。

与常规可观察性不同,LiveData具有生命周期感知能力,这意味着它尊重其他应用程序组件(例如Activities,Fragments或Services)的生命周期。这种意识确保LiveData只更新处于活动生命周期状态的应用程序组件观察者。

如果LiveData的 Observer 生命周期处于 STARTEDRESUMED 状态,LiveData将认为由该类表示的观察者处于活动状态。LiveData仅通知活跃的观察员关于更新。 LiveData 未注册观察对象的

非活动观察者不会收到有关更改的通知。

总结为以下三点:

  • 数据可以被观察者订阅;

  • 能够感知组件(Fragment、Activity、Service)的生命周期;

  • 只有在组件出于激活状态(STARTED、RESUMED)才会通知观察者有数据更新;

2、LiveData的优点

  • 保证数据和UI统一

LiveData遵循观察者模式。Observer当生命周期状态改变时,LiveData会通知对象。 你可以合并代码以更新这些Observer对象中的UI 。 每次应用程序数据更改时,你的观察者都可以在每次更改时更新UI,而不是每次更新UI。

  • 减少内存泄漏

这是因为LiveData能够感知到组件的生命周期,当组件处于DESTROYED状态时,观察者对象会被清除掉。

  • Activity停止时不会发生崩溃

如果观察者的生命周期处于非活动状态,例如在后退堆栈中的Activity,不会收到任何LiveData事件。

  • 不需要额外的手动处理来响应生命周期的变化

UI组件只是观察相关数据,不会停止或重复观察。
LiveData自动管理所有这些,因为它在观察时意识到相关的生命周期状态更改。
  • 始终保持最新的数据

如果生命周期变为非活动状态,它将在再次变为活动状态时收到最新数据。

例如,在请求数据时应用退到后台,此时不会向控件中加载数据,当应用回到前台时,控件会立即收到最新数据。

  • 针对configuration change时,不需要额外的处理来保存数据

我们知道,当你把数据存储在组件中时,当configuration change(比如语言、屏幕方向变化)时,组件会被recreate,然而系统并不能保证你的数据能够被恢复的。当我们采用LiveData保存数据时,因为数据和组件分离了。当组件被recreate,数据还是存在LiveData中,并不会被销毁。

  • 资源共享

通过继承LiveData类,然后将该类定义成单例模式,在该类封装监听一些系统属性变化,然后通知LiveData的观察者。 任何需要该资源的观察者都可以观察该 LiveData 对象。 这个在 继承LiveData 中会看到具体的例子。

3、LiveData的使用

在了解LiveData定义和优点后,那它到底怎么应用呢?LiveData有几种使用方式:

  • 使用LiveData

  • 继承LiveData

  • 转换LiveData

1)使用LiveData

使用LiveData对象主要有三个步骤:

  1. 创建LiveData对象

  2. 观察LiveData对象

  3. 更新LiveData对象

创建LiveData

Android文档中建议LiveData配合ViewModel使用。LiveData是一个包装器,可用于任何数据,包括实现的对象Collections,例如List。一个 LiveData对象通常存储在一个ViewModel 对象中,并通过getter方法访问。

public class NameViewModel extends ViewModel {

// Create a LiveData with a String
private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData<String>();
        }
        return mCurrentName;
    }

// Rest of the ViewModel...
}

观察LiveData

大多数情况下,Activity或Fragment的onCreate方法是观察LiveData的正确位置,原因有以下两点:

  • 确保系统不会从Activity或Fragment的onResume()方法进行多余的调用。

  • 确保Activity或Fragment具有一旦它变为活动状态即可显示的数据。只要应用程序组件处于该 STARTED 状态,它就会从LiveData它所观察的对象中接收最新的值。只有当LiveData要观察的对象已被设置时才会发生这种情况。

通常,LiveData仅在数据更改时传递更新,并且仅传递给活动观察者。

此行为的一个例外是,观察者在从非活动状态变为活动状态时也会收到更新。

此外,如果观察者第二次从非激活状态变为激活状态,则只有在自上一次变为活动状态以来该值发生变化时才会收到更新。

public class NameActivity extends AppCompatActivity {

    private NameViewModel mModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Other code to setup the activity...

        // Get the ViewModel.
        mModel = ViewModelProviders.of(this).get(NameViewModel.class);


        // Create the observer which updates the UI.
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                mNameTextView.setText(newName);
            }
        };

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        mModel.getCurrentName().observe(this, nameObserver);
    }
}

更新LiveData

LiveData没有公开可用的方法来更新存储的数据。MutableLiveData 类公开 setValue(T) 和 postValue(T) 方法,如果你需要编辑存储在LiveData对象中的值,你必须使用这些方法。

mButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        String anotherName = "Google";
        mModel.getCurrentName().setValue(anotherName);
    }
});

LiveData提供了两种改变数据的方法:setValue()和postValue()。区别是setValue()要在主线程中调用,而postValue()既可在主线程也可在子线程中调用。

2)继承LiveData

除了直接使用LiveDatad对象外,我们还可以通过继承LiveData类来定义适合特定需求的LiveData。下面继承LiveData类的例子,验证下LiveData的其中一个优点—— 资源共享

public class MyLiveData extends LiveData<Integer> {
    private static final String TAG = "MyLiveData";
    private static MyLiveData sData;
    private WeakReference<Context> mContextWeakReference;
    public static MyLiveData getInstance(Context context){
        if (sData == null){
            sData = new MyLiveData(context);
        }
        return sData;
    }
    private MyLiveData(Context context){
        mContextWeakReference = new WeakReference<>(context);
    }
    @Override
    protected void onActive() {
        super.onActive();
        registerReceiver();
    }
    @Override
    protected void onInactive() {
        super.onInactive();
        unregisterReceiver();
    }
    private void registerReceiver() {
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        mContextWeakReference.get().registerReceiver(mReceiver, intentFilter);
    }
    private void unregisterReceiver() {
        mContextWeakReference.get().unregisterReceiver(mReceiver);
    }
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            Log.d(TAG, "action = " + action);
            if (WifiManager.RSSI_CHANGED_ACTION.equals(action)) {
                int wifiRssi = intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200);
                int wifiLevel = WifiManager.calculateSignalLevel(
                        wifiRssi, 4);
                sData.setValue(wifiLevel);
            }
        }
    };
}

MyLiveData是个继承了LiveData的单例类,在onActive()和onInactive()方法中分别注册和反注册Wifi信号强度的广播。然后在广播接收器中更新MyLiveData对象。在使用的时候就可以通过MyLiveData.getInstance()方法,然后通过调用observe()方法来添加观察者对象,订阅Wifi信息强度变化。

3)转换LiveData

LiveData 还支持简单的数据变换。目前在 Transformations 类中有 map 和 switchMap 两个变换函数,如果属性 RxJava 则对这两个函数应该不陌生:

  • map 是把一个数据类型变换为另外一个数据类型。

  • switchMap 是把一个数据变化为另外一个 LiveData 。

public class LiveDataActivity extends LifecycleActivity {
    private TextView mTextView;
    private TextView mCountryTV;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.text);
        mCountryTV = (TextView) findViewById(R.id.country);

        demoTransformation();
    }

    private void demoTransformation() {
        LocationLiveData data = LocationLiveData.getsIns(this);
        LiveData<String> stringLatLon = Transformations.map(data,
                location -> location.getLatitude() + ", " + location.getLongitude());
        stringLatLon.observe(this, latLon -> {
            mTextView.setText(latLon);
        });

        Transformations.switchMap(data, location -> getCountryName(location))
            .observe(this, country -> mCountryTV.setText(country));
    }

    // 返回当前位置所在的国家名字
    private LiveData<String> getCountryName(Location loc) {
        // 只是为了演示,实际中需要把转换的逻辑封装到自定义的 LiveData 中,
        // 和 LocationLiveData 类似
        MutableLiveData<String> ld = new MutableLiveData<>();
        ld.postValue("中国");
        return ld;
    }
}

使用 Transformation 的好处是可以共享 Lifecycle。如果 Lifecycle 处于未激活状态,则转换函数不会执行。

当你在 ViewModel 中需要一个 Lifecycle 的时候,则可能这个时候就需要使用 Transformation 了。

例如,你现在有个让用户输入地址的界面,当用户输入地址后,去获取对应的邮编,下面是一种天真的 ViewModel 实现方式:

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    public MyViewModel(PostalCodeRepository repository) {
       this.repository = repository;
    }

    private LiveData<String> getPostalCode(String address) {
       // 不要这样干!!!
       return repository.getPostCode(address);
    }
}

上面实现的问题是,当每次调用 getPostalCode() 函数的时候, UI 都需要从前一个 LiveData 中取消注册然后重新注册到 getPostalCode() 函数返回的 LiveData 中。如果 UI 重新创建了,甚至会导致 repository.getPostCode() 重新被调用而不是使用之前缓存的值。

可以使用 Transformation 的 switchMap 来解决上面的问题,把输入的地址当做一个 LiveData,然后根据地址的变化去获取邮编:

class MyViewModel extends ViewModel {
    private final PostalCodeRepository repository;
    private final MutableLiveData<String> addressInput = new MutableLiveData();
    public final LiveData<String> postalCode =
            Transformations.switchMap(addressInput, (address) -> {
                return repository.getPostCode(address);
             });

    public MyViewModel(PostalCodeRepository repository) {
        this.repository = repository
    }

    private void setInput(String address) {
        addressInput.setValue(address);
    }
}

注意 上面的 postalCode 变量由于无需变化,所以声明为 final 的。postalCode 定义了一个 Transformation 把 addressInput 转换为 邮编。当地址发生变化的时候,如果有活动的 Observer 则会触发 repository.getPostCode() 函数去请求邮编,如果没有活动的 Observer ,则该函数不会执行,当有活动的 Observer 后会继续执行。

有十几种不同的特定转换可能在你的应用中很有用,但它们不是默认提供的。为了实现你自己的转换,你可以使用这个MediatorLiveData 类来监听其他 LiveData对象并处理它们发出的事件。MediatorLiveData正确地将其状态传播到源LiveData对象。要了解更多关于这种模式的信息,请参阅Transformations 该类的参考文档

-----------------------------------------------------

ViewModel

1、ViewModel是什么

ViewModel,从字面上理解的话,我们也能想到它肯定是跟视图(View)以及数据(Model)相关的。正像它字面意思一样,它是负责准备和管理和UI组件(Fragment/Activity)相关的数据类,也就是说ViewModel是用来管理UI相关的数据的。同时ViewModel还可以用来负责UI组件间的通信,这一点后面我们会有例子说明。

2、ViewModel能够做什么

  • 保存(获取)数据

当Activity因为配置更改重新创建时,Activity必须重新获取数据。对于简单的数据,Activity可以使用 onSaveInstanceState()方法并从数据包中恢复其数据 ,但是此方法仅适用于可以序列化然后反序列化的少量数据,而不适用于潜在的大量数据,如用户列表或位图,而由于ViewModel贯穿了Activity的整个生命周期,且recreate时仍然存在,则可以用于保存/获取数据

  • 异步获取数据

UI控制器经常需要进行异步调用,这可能需要一些时间才能返回。UI控制器需要管理这些调用,并确保系统在销毁后清理它们以避免潜在的内存泄漏或崩溃。而通过ViewModel,可以拥有跟随Activity或Fragment的生命周期,无需关心内存泄漏和崩溃。

  • UI组件(Fragment)之间的通信

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData<Item> getSelected() {
        return selected;
    }
}


public class MasterFragment extends Fragment {
    private SharedViewModel model;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, item -> {
           // Update the UI.
        });
    }
}

3、ViewModel的基本使用

在LiveData中已经使用了ViewModel,大家不记得的可以回头去看 LiveData

4、ViewModel生命周期

先来看下官网的一张图

上图是用Activity作为例子,左侧表示Activity的生命周期状态,右侧绿色部分表示ViewModel的生命周期范围。当屏幕旋转的时候,Activity会被recreate,Activity会经过几个生命周期方法,但是这个时候ViewModel还是之前的对象,并没有被重新创建,只有当Activity的finish()方法被调用时,ViewModel.onCleared()方法会被调用,对象才会被销毁。这张图很好的描述了是当Activity被recreate时,ViewModel的生命周期。

另外,有个注意的地方: 在ViewModel中不要持有Activity的引用 。为什么要注意这一点呢?从上面的图我们看到,当Activity被recreate时,ViewModel对象并没有被销毁,如果Model持有Activity的引用时就可能会导致内存泄漏。那如果你要使用到Context对象怎么办呢,那就使用ViewModel的子类  AndroidViewModel 吧。

5、实现原理

类图

  • ViewModelProviders是ViewModel工具类,该类提供了通过Fragment和Activity得到ViewModel的方法,而具体实现又是有ViewModelProvider实现的。ViewModelProvider是实现ViewModel创建、获取的工具类。在ViewModelProvider中定义了一个创建ViewModel的接口类——Factory。ViewModelProvider中有个ViewModelStore对象,用于存储ViewModel对象。

  • ViewModelStore是存储ViewModel的类,具体实现是通过HashMap来保存ViewModle对象。

  • ViewModel是个抽象类,里面只定义了一个onCleared()方法,该方法在ViewModel不在被使用时调用。ViewModel有一个子类AndroidViewModel,这个类是便于要在ViewModel中使用Context对象,因为我们前面提到是不能在ViewModel中持有Activity的引用。

  • ViewModelStores是ViewModelStore的工厂方法类,它会关联HolderFragment,HolderFragment有个嵌套类——HolderFragmentManager。

时序图

在使用ViewModel的例子中,也许你会察觉得到一个ViewModel对象需要的步骤有点多啊,怎么不直接new一个出来呢?在你看到ViewModel的类图关系后,你应该就能明白了,因为是会缓存ViewModel对象的。下面以在Fragment中得到ViewModel对象为例看下整个过程的时序图。

时序图看起来比较复杂,但是它只描述了两个过程:

  • 得到ViewModel对象。

  • HolderFragment被销毁时,ViewModel收到onCleared()通知。

大家也可以结合时序图分析一下源码!

本文作者:Android研发部 - 张常安

----------  END  ----------

我来评几句
登录后评论

已发表评论数()

相关站点

+订阅
热门文章