Jetpack-ViewModel

Jetpack-Lifecycle

Jetpack-LiveData

ViewModel

ViewModel是以能感知生命周期的方式存储和管理界面相关数据的组件。感知生命周期是说当Activity或Fragment创建第一个实例的时候,它开始创建,当Activity销毁或者Fragment分离的时候,它自动清理。比如:当屏幕旋转时,它不会被重新创建,数据能够被恢复。

当Activity配置发生变化时,我们也可以通过onSaveInstanceState() 方法保存数据,从 onCreate()onRestoreInstanceState方法中恢复其数据,但这种方式仅适合可以序列化再反序列化的少量数据,而不适合较大数量的数据,如用户列表;而ViewModel可以。

Activity或Fragment主要用于界面的展示,如果数据存储和恢复的相关逻辑放在其中,会使Activity或Fragment变得臃肿。使用ViewModel可以将它们分离开来。

使用

class MyViewModel : ViewModel() {
    private val users: MutableLiveData<List<User>> by lazy {
        MutableLiveData().also {
            it.value = loadUsers()
        }
    }

    fun getUsers(): LiveData<List<User>> {
        return users
    }

    private fun loadUsers():List<User> {
        //todo
    }
}
class MyActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        //通过ViewModelProviders获取ViewModel实例
        val model = ViewModelProviders.of(this)[MyViewModel::class.java]
        model.getUsers().observe(this, Observer<List<User>>{ users ->
            //todo
        })
    }
}

ViewModel还存在一个子类:AndroidViewModel,它的构造方法接收一个Application类型的参数,方便在ViewModel中使用Context

//定义
class MyViewModel(application:Application) : AndroidViewModel(application) {}

//获取实例
mViewModel = ViewModelProviders.of(this,ViewModelProvider.AndroidViewModelFactory(application)).get(MyViewModel::class.java)

从上面看到当ViewModel的构造方法中有参数时,在获取实例的时候,传入了一个参数:ViewModelProvider.factory,那么这个Factory的作用是什么呢?当我们调用ViewModelProviders.of(activity)获取ViewModel实例的时候,它内部会默认调用ViewModel无参构造方法来创建实例;但是当ViewModel的构造方法有依赖时,这时候就需要我们自定义Factory来实例化ViewModel。比如:ViewModel的构造方法含有一个Int类型的参数,Factory的实现如下:

class MyViewModel(id: Int) : ViewModel() {}

//自定义Factory 
class MyViewModelFactory(private val arg: Int) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        return modelClass.getConstructor(Int::class.java).newInstance(arg)
    }
}

生命周期

ViewModel的存在是从第一次获取ViewModel实例一直到Activity完全销毁或者Fragment分离,Activity因配置发生变化而重新创建时,ViewModel是不会重新创建的。

当ViewModel销毁的时候,它会调用onCleared()方法,来清理相关的资源。

因为ViewModel比Activity的生命周期要长,所以ViewMode一定不能持有View的引用。

实现原理

我们要使用ViewModel,首先调用ViewModelProviders.of(this).get(MyViewModel::class.java)来获取实例。我们就以此为分析的入口,看一下该方法的实现:

public static ViewModelProvider of(@NonNull FragmentActivity activity) {
    return of(activity, null);
}

public static ViewModelProvider of(@NonNull FragmentActivity activity,@Nullable Factory factory) {
    Application application = checkApplication(activity);
    if (factory == null) {
        factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
    }
    return new ViewModelProvider(activity.getViewModelStore(), factory);
}

从上面可以看出最终都会调用两个参数的方法,new ViewModelProvider(activity.getViewModelStore(), factory);,第一个参数通过Activity获取一个ViewModelStore对象,该方法是在ComponentActivity中实现的:

public ViewModelStore getViewModelStore() {
    if (getApplication() == null) {
        throw new IllegalStateException("Your activity is not yet attached to the "
                + "Application instance. You can't request ViewModel before onCreate call.");
    }
    if (mViewModelStore == null) {
        NonConfigurationInstances nc = (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null) {
            // Restore the ViewModelStore from NonConfigurationInstances
            mViewModelStore = nc.viewModelStore;
        }
        if (mViewModelStore == null) {
            mViewModelStore = new ViewModelStore();
        }
    }
    return mViewModelStore;
}

Activity在配置发生变化时,如横竖屏切换会触发onSaveInstanceState()方法来保存状态,除此之外Activity还提供了一个方法onRetainNonConfigurationInstance来保存状态,最大的不同在于这个方法可以返回一个包含有状态信息的Object。该方法是在onSaveInstanceState()方法之后调用,该方法不允许重写。

public final Object onRetainNonConfigurationInstance() {
    Object custom = onRetainCustomNonConfigurationInstance();

    ViewModelStore viewModelStore = mViewModelStore;
    if (viewModelStore == null) {
        // No one called getViewModelStore(), so see if there was an existing
        // ViewModelStore from our last NonConfigurationInstance
        NonConfigurationInstances nc =
                (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null) {
            viewModelStore = nc.viewModelStore;
        }
    }

    if (viewModelStore == null && custom == null) {
        return null;
    }

    NonConfigurationInstances nci = new NonConfigurationInstances();
    nci.custom = custom;
    nci.viewModelStore = viewModelStore;
    return nci;
}

Activity在配置发生变化的时候保存了viewModelStore,放到了NonConfigurationInstances中。上面的操作都围绕着ViewModelStore,那么看一下它到底是什么?

public class ViewModelStore {

    private final HashMap<String, ViewModel> mMap = new HashMap<>();

    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.put(key, viewModel);
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
    }

    final ViewModel get(String key) {
        return mMap.get(key);
    }

    Set<String> keys() {
        return new HashSet<>(mMap.keySet());
    }

    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.clear();
        }
        mMap.clear();
    }
}

ViewModelStore的代码很简单,就是用一个HashMap来存储ViewModel。那么ViewModel又是从什么时候存进去的呢?那就要从ViewModel的创建说起,我们获取ViewModel的实例调用的是ViewModelProvider的get()方法。

public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
    String canonicalName = modelClass.getCanonicalName();
    if (canonicalName == null) {
        throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
    }
    return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}

public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
    ViewModel viewModel = mViewModelStore.get(key);

    if (modelClass.isInstance(viewModel)) {
        return (T) viewModel;
    } else {
        //noinspection StatementWithEmptyBody
        if (viewModel != null) {
            // TODO: log a warning.
        }
    }
    if (mFactory instanceof KeyedFactory) {
        viewModel = ((KeyedFactory) (mFactory)).create(key, modelClass);
    } else {
        viewModel = (mFactory).create(modelClass);
    }
    mViewModelStore.put(key, viewModel);
    return (T) viewModel;
}

get()方法的实现也比较简单:先判断缓存中是否存在ViewModel,如果不存在就使用Factory创建一个实例,然后加入到缓存中。

ViewModel存储在ViewModelStore中,而ViewModelStore在Activity配置变化的时候会在onRetainNonConfigurationInstance()方法中保存起来,也就是说ViewModelStore不会因为Activity配置发生变化而重新创建。所以ViewModel也不会重新创建。

那么ViewModel是在什么时候销毁的呢?ViewModel存储在ViewModelStore里面的mMap中,它中有一个clear()方法,用来清除这个mMap,也就是清除ViewModel,那么我们就看一下这个方法是在哪里调用的?

public ComponentActivity() {
    ...
    getLifecycle().addObserver(new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            if (event == Lifecycle.Event.ON_DESTROY) {
                if (!isChangingConfigurations()) {
                    getViewModelStore().clear();
                }
            }
        }
    });
    ...
}

在Activity创建的时候会通过Lifecycle添加一个观察者,观察Activity的ON_DESTROY状态。当处于该状态时,判断是否是配置变化触发的,如果不是则调用ViewModelStore的clear()方法。从这里也可以看出,当Activity配置变化的时候并不会清理ViewModel。在Jetpack-Lifecycle中我们知道,当Activity调用onDestroy()时,状态会变为ON_DESTROY

public final void clear() {
    for (ViewModel vm : mMap.values()) {
        vm.clear();
    }
    mMap.clear();
}

clear()方法中会调用ViewModel的clear()方法

final void clear() {
    mCleared = true;
    if (mBagOfTags != null) {
        synchronized (mBagOfTags) {
            for (Object value : mBagOfTags.values()) {
                // see comment for the similar call in setTagIfAbsent
                closeWithRuntimeException(value);
            }
        }
    }
    onCleared();
}

protected void onCleared() {
}

所以在ViewModel即将销毁的时候会回调它的onCleared()方法,我们可以在该方法中做一些清理的工作。

KotlinAndroid

推荐阅读更多精彩内容