[Android] Jetpack的ViewModel与LiveData

ViewModelProviders.of(this).get(MyViewModel::class.java)

@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
  return of(activity, null);
}
/**
 * Creates a {@link ViewModelProvider}, which retains ViewModels while a scope of given Activity
 * is alive. More detailed explanation is in {@link ViewModel}.
 * <p>
 * It uses the given {@link Factory} to instantiate new ViewModels.
 *
 * @param activity an activity, in whose scope ViewModels should be retained
 * @param factory  a {@code Factory} to instantiate new ViewModels
 * @return a ViewModelProvider instance
 */
@NonNull
@MainThread
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);
}

private final Factory mFactory;
private final ViewModelStore mViewModelStore;
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
  mFactory = factory;
  this.mViewModelStore = store;
}

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);
  }
  /**
   *  Clears internal storage and notifies ViewModels that they are no longer used.
   */
  public final void clear() {
    for (ViewModel vm : mMap.values()) {
      vm.onCleared();
    }
    mMap.clear();
  }
}

@NonNull
 @MainThread
 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);
 }
@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
  ViewModel viewModel = mViewModelStore.get(key);
  if (modelClass.isInstance(viewModel)) {
    //noinspection unchecked
    return (T) viewModel;
  } else {
    //noinspection StatementWithEmptyBody
    if (viewModel != null) {
      // TODO: log a warning.
    }
  }
  viewModel = mFactory.create(modelClass);
  mViewModelStore.put(key, viewModel);
  //noinspection unchecked
  return (T) viewModel;
}

@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
  if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
    //noinspection TryWithIdenticalCatches
    try {
      return modelClass.getConstructor(Application.class).newInstance(mApplication);
    } catch (NoSuchMethodException e) {
      throw new RuntimeException("Cannot create an instance of " + modelClass, e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException("Cannot create an instance of " + modelClass, e);
    } catch (InstantiationException e) {
      throw new RuntimeException("Cannot create an instance of " + modelClass, e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException("Cannot create an instance of " + modelClass, e);
    }
  }
  return super.create(modelClass);
}

@NonNull
@MainThread
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);
}

@NonNull
@Override
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;
}

static final class NonConfigurationInstances {
    Object activity;
    HashMap<String, Object> children;
    FragmentManagerNonConfig fragments;
    ArrayMap<String, LoaderManager> loaders;
    VoiceInteractor voiceInteractor;
  }
  /* package */ NonConfigurationInstances mLastNonConfigurationInstances;
@Nullable
public Object getLastNonConfigurationInstance() {
  return mLastNonConfigurationInstances != null
      ? mLastNonConfigurationInstances.activity : null;
}

static final class NonConfigurationInstances {
  Object custom;
  ViewModelStore viewModelStore;
  FragmentManagerNonConfig fragments;
}

viewModel?.livaData?.observe(this, Observer<Int> { integer -> Log.d("MainActivity", integer!!.toString()) })

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
  assertMainThread("observe");
  if (owner.getLifecycle().getCurrentState() == DESTROYED) {
    // ignore
    return;
  }
  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;
  }
  owner.getLifecycle().addObserver(wrapper);
}

private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
      new SafeIterableMap<>();

public class MutableLiveData<T> extends LiveData<T> {
  @Override
  public void postValue(T value) {
    super.postValue(value);
  }
  @Override
  public void setValue(T value) {
    super.setValue(value);
  }
}

protected void postValue(T value) {
  boolean postTask;
  synchronized (mDataLock) {
    postTask = mPendingData == NOT_SET;
    mPendingData = value;
  }
  if (!postTask) {
    return;
  }
  ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

@MainThread
protected void setValue(T value) {
  assertMainThread("setValue");
  mVersion++;
  mData = value;
  dispatchingValue(null);
}

void dispatchingValue(@Nullable ObserverWrapper initiator) {
  if (mDispatchingValue) {
    mDispatchInvalidated = true;
    return;
  }
  mDispatchingValue = true;
  do {
    mDispatchInvalidated = false;
    if (initiator != null) {
      considerNotify(initiator);
      initiator = null;
    } else {
      for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
          mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
        considerNotify(iterator.next().getValue());
        if (mDispatchInvalidated) {
          break;
        }
      }
    }
  } while (mDispatchInvalidated);
  mDispatchingValue = false;
}

for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
  considerNotify(iterator.next().getValue());
  if (mDispatchInvalidated) {
    break;
  }
}

private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
    new SafeIterableMap<>();

private void considerNotify(ObserverWrapper observer) {
  if (!observer.mActive) {
    return;
  }
  // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
  //
  // we still first check observer.active to keep it as the entrance for events. So even if
  // the observer moved to an active state, if we've not received that event, we better not
  // notify for a more predictable notification order.
  if (!observer.shouldBeActive()) {
    observer.activeStateChanged(false);
    return;
  }
  if (observer.mLastVersion >= mVersion) {
    return;
  }
  observer.mLastVersion = mVersion;
  //noinspection unchecked
  observer.mObserver.onChanged((T) mData);
}

@Override
boolean shouldBeActive() {
  return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}

@Override
public void onStateChanged(@NonNull LifecycleOwner source,
    @NonNull Lifecycle.Event event) {
  if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
    removeObserver(mObserver);
    return;
  }
  activeStateChanged(shouldBeActive());
}

private void considerNotify(ObserverWrapper observer) {
  if (!observer.mActive) {
    return;
  }
  // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
  //
  // we still first check observer.active to keep it as the entrance for events. So even if
  // the observer moved to an active state, if we've not received that event, we better not
  // notify for a more predictable notification order.
  if (!observer.shouldBeActive()) {
    observer.activeStateChanged(false);
    return;
  }
  if (observer.mLastVersion >= mVersion) {
    return;
  }
  observer.mLastVersion = mVersion;
  observer.mObserver.onChanged((T) mData);
}

if (observer.mLastVersion >= mVersion) {
  return;
}