Android--MVVM之ViewModel

//第一个参数：ViewModelStoreOwner
//第二个参数：ViewModelProvider.Factory
new ViewModelProvider(this,new ViewModelProvider.NewInstanceFactory()).get(HttpViewModel.class);

//这一行代码是干什么的呢？
ComponentActivity.this.getViewModelStore().clear();

public class ViewModelStore {
    //HashMap,以String为key，ViewModel为值存放ViewModel
    private final HashMap<String, ViewModel> mMap = new HashMap();

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

    }
    
    //获取ViewModel
    final ViewModel get(String key) {
        return (ViewModel)this.mMap.get(key);
    }

    Set<String> keys() {
        return new HashSet(this.mMap.keySet());
    }
    
    //看代码，就是一个迭代器，循环调用每个ViewModel的clear方法，最后，清空迭代器
    //看到这里，就应该联想到了吧？
    public final void clear() {
        Iterator var1 = this.mMap.values().iterator();

        while(var1.hasNext()) {
            ViewModel vm = (ViewModel)var1.next();
            vm.clear();
        }

        this.mMap.clear();
    }
}

this.getLifecycle().addObserver(new LifecycleEventObserver() {
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        //看这里销毁的条件，并不是只有一个，而是有两个，
        //销毁事件满足了，后面那个条件又是什么呢？
        if (event == Event.ON_DESTROY && !ComponentActivity.this.isChangingConfigurations()) {
            ComponentActivity.this.getViewModelStore().clear();
        }
    }
});

//检查是否这个activity是否处于正在销毁的为过程中，为了重新创建带有一个新的配置
//有没有一点想法？
//意思就是说，这个activity是不是因为一个新的配置需要重新创建而被销毁了。
//（我不管你们认不认，反正，我觉得可以这样理解）
Check to see whether this activity is in the process of being destroyed in order to be recreated with a new configuration. 
...

//看这个return的注释
//如果，这个activity是需要根据新的配置重新创建而被销毁的话，就返回true，否则，就返回false。
Returns:
If the activity is being torn down in order to be recreated with a new configuration, returns true; else returns false.

public boolean isChangingConfigurations() {
    return mChangingConfigurations;
}

//新建ViewModelProvider，调用了它两个参数的构造方法，获取ViewModelProvider，然后通过它的get方法获取ViewModel
new ViewModelProvider(this,new ViewModelProvider.NewInstanceFactory()).get(HttpViewModel.class);

//我们一层一层的追溯
public class ViewModelProvider {
    //默认的key值，这里后面存ViewModel有用到
    private static final String DEFAULT_KEY = "androidx.lifecycle.ViewModelProvider.DefaultKey";
    private final ViewModelProvider.Factory mFactory;
    private final ViewModelStore mViewModelStore;

    public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull ViewModelProvider.Factory factory) {
        //我们再来看看ViewModelStoreOwner的getViewModelStore是怎么实现的
        this(owner.getViewModelStore(), factory);
    }
    //上面的构造方法，调用的就是这个构造方法
    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull ViewModelProvider.Factory factory) {
        this.mFactory = factory;
        this.mViewModelStore = store;
    }
    ...
}

//看到这里就大概能够猜到，这里这么多判断空，肯定是复用了呀。
@NonNull
public ViewModelStore getViewModelStore() {
    //判断application有没有，没有就直接抛异常了
    if (this.getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
    } else {
        //mViewModelStore为空就重新赋值
        if (this.mViewModelStore == null) {
            //这里是先获取了上一次配置的NonConfigurationInstances对象，它不为空，就把它的viewModelStore变量，赋值到这里
            ComponentActivity.NonConfigurationInstances nc = (ComponentActivity.NonConfigurationInstances)this.getLastNonConfigurationInstance();
            if (nc != null) {
                this.mViewModelStore = nc.viewModelStore;
            }
            //到这里还是空，说明没有获取到，就重新new一个
            if (this.mViewModelStore == null) {
                this.mViewModelStore = new ViewModelStore();
            }
        }

        return this.mViewModelStore;
    }
}

...
//返回先前的对象，通过onRetainNonConfigurationInstance()方法
Returns:
the object previously returned by onRetainNonConfigurationInstance()


//我们再来看这个方法，直接返回了null，我们再看这个注释
public Object onRetainNonConfigurationInstance() {
    return null;
}

//先直译：
//被系统调用，作为activity销毁的一部分，由于配置发生了改变
//当它知道一个新对象会被立马创建为了这个新配置
//就是说：当activity需要被立马被重新创建，因为配置发生变化被销毁的时候，这个方法会被系统调用
Called by the system, as part of destroying an activity due to a configuration change, when it is known that a new instance will immediately be created for the new configuration. 

//你能返回任意对象，你想要的在这里包括activity对象本身，
//稍后被恢复通过调用getLastNonConfigurationInstance()方法在新的activity对象里面
//就是说：activity前面不是说重新创建了吗？
//当在新的activity里面调用getLastNonConfigurationInstance方法的时候，能返回你想要的任意对象包括activity本身
You can return any object you like here, including the activity instance itself, which can later be retrieved by calling getLastNonConfigurationInstance() in the new activity instance.

public Object getLastNonConfigurationInstance() {
    //mLastNonConfigurationInstances这个变量赋值的位置是attach方法，这个方法也是系统调用的。
    return mLastNonConfigurationInstances != null
                ? mLastNonConfigurationInstances.activity : null;
}

public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull ViewModelProvider.Factory factory) {
        //在ViewModelProvider重新创建的时候，owner.getViewModelStore()获取到的ViewModelStore还是原先的
        //因为，这里的获取最终都是系统调用赋值的，也不知道最开始的值是不是相同的。就认为是相同的
        this(owner.getViewModelStore(), factory);
    }

@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
    //这里获取了类的getCanonicalName值
    String canonicalName = modelClass.getCanonicalName();
    //判断是否为空
    if (canonicalName == null) {
        throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
    } else {
        //看这里字符串眼熟吗？上面说过了那个DEFAULT_KEY变量，然后加上这个类的路径名
        return this.get("androidx.lifecycle.ViewModelProvider.DefaultKey:" + canonicalName, modelClass);
    }
}

@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
    //通过这个key先获取ViewModel
    ViewModel viewModel = this.mViewModelStore.get(key);
    //判断是不是这个类的对象，怎么实现的，我不知道，是native方法
    if (modelClass.isInstance(viewModel)) {
        return viewModel;
    } else {
        if (viewModel != null) {
        }
        
        //这个mFactory是我们创建的时候传的单例对象，这都不是重点
        if (this.mFactory instanceof ViewModelProvider.KeyedFactory) {
            viewModel = ((ViewModelProvider.KeyedFactory)((ViewModelProvider.KeyedFactory)this.mFactory)).create(key, modelClass);
        } else {
            viewModel = this.mFactory.create(modelClass);
        }
        //重点就是这里，它会先把这个对象存到ViewModelStore里面，然后，再返回这个对象。第一行，就是先通过这个对象先获取。
        this.mViewModelStore.put(key, viewModel);
        return viewModel;
    }
}

//把我们之前第一个参数的位置，传递getActivity()即可。
new ViewModelProvider(getActivity(),new ViewModelProvider.NewInstanceFactory()).get(HttpViewModel.class);