一文搞懂Android JetPack组件原理之Lifecycle、LiveData、ViewModel与源码分析技巧

mkdir ~/bin
PATH=~/bin:$PATHcurl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repochmod a+x ~/bin/repo

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

mkdir androidx-master-devcd androidx-master-dev

repo init -u https://android.googlesource.com/platform/manifest -b androidx-master-devrepo sync -j8 -c

cd androidx-master-dev/frameworks/support/./studiow

MyObserver implements LifecycleObserver {    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)    public void connectListener() {        ...    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)    public void disconnectListener() {        ...    }}
lifecycleOwner.getLifecycle().addObserver(new MyObserver());

MutableLiveData<String> liveString = new MutableLiveData<>();liveString.observe(mOwner, new Observer<String>() {    @Override    public void onChanged(@Nullable final String s) {        Log.d(TAG, "onChanged() called with: s = [" + s + "]");    }});
liveString.setValue("LiveData使用案例");

public class MyViewModel extends ViewModel {    private MutableLiveData<List<User>> users;    public LiveData<List<User>> getUsers() {        if (users == null) {            users = new MutableLiveData<List<User>>();            loadUsers();        }        return users;    }
    private void loadUsers() {        // Do an asynchronous operation to fetch users.    }}

MyObserver implements LifecycleObserver {    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)    public void connectListener() {        ...    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)    public void disconnectListener() {        ...    }}
lifecycleOwner.getLifecycle().addObserver(new MyObserver());

public class ComponentActivity extends Activity implements LifecycleOwner, Component {
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        ReportFragment.injectIfNeededIn(this);    }
    @CallSuper    protected void onSaveInstanceState(Bundle outState) {        Lifecycle lifecycle = this.getLifecycle();        if (lifecycle instanceof LifecycleRegistry) {            ((LifecycleRegistry)lifecycle).setCurrentState(State.CREATED);        }
        super.onSaveInstanceState(outState);    }
    public Lifecycle getLifecycle() {        return this.mLifecycleRegistry;    }}

public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"            + ".LifecycleDispatcher.report_fragment_tag";        public static void injectIfNeededIn(Activity activity) {        if (Build.VERSION.SDK_INT >= 29) {            // On API 29+, we can register for the correct Lifecycle callbacks directly            activity.registerActivityLifecycleCallbacks(                    new LifecycleCallbacks());        }        // Prior to API 29 and to maintain compatibility with older versions of        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and        // need to support activities that don't extend from FragmentActivity from support lib),        // use a framework fragment to get the correct timing of Lifecycle events        android.app.FragmentManager manager = activity.getFragmentManager();        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();            // Hopefully, we are the first to make a transaction.            manager.executePendingTransactions();        }    }    //...       @Override    public void onStart() {        super.onStart();        dispatchStart(mProcessListener);        dispatch(Lifecycle.Event.ON_START);    }        private void dispatch(@NonNull Lifecycle.Event event) {        if (Build.VERSION.SDK_INT < 29) {            // Only dispatch events from ReportFragment on API levels prior            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks            // added in ReportFragment.injectIfNeededIn            dispatch(getActivity(), event);        }    }         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);            }        }    }   //...}

public class LifecycleRegistry extends Lifecycle {   /**    * Custom list that keeps observers and can handle removals / additions during traversal.    *    * Invariant: at any moment of time for observer1 & observer2:    * if addition_order(observer1) < addition_order(observer2), then    * state(observer1) >= state(observer2),    */    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();    private State mState;    private final WeakReference<LifecycleOwner> mLifecycleOwner;        public LifecycleRegistry(@NonNull LifecycleOwner provider) {        mLifecycleOwner = new WeakReference<>(provider);        mState = INITIALIZED;    }       public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {        State next = getStateAfter(event);        moveToState(next);    }
    private void moveToState(State next) {        if (mState == next) {            return;        }        mState = next;        ......        sync();        ......    }    ...}

static State getStateAfter(Event event) {    switch(event) {        case ON_CREATE:        case ON_STOP:            return State.CREATED;        case ON_START:        case ON_PAUSE:            return State.STARTED;        case ON_RESUME:            return State.RESUMED;        case ON_DESTROY:            return State.DESTROYED;        case ON_ANY:        default:            throw new IllegalArgumentException("Unexpected event value " + event);    }}

/** * Custom list that keeps observers and can handle removals / additions during traversal. * * Invariant: at any moment of time for observer1 & observer2: * if addition_order(observer1) < addition_order(observer2), then * state(observer1) >= state(observer2), */private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();

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 = getStateAfter(event);        mState = min(mState, newState);        mLifecycleObserver.onStateChanged(owner, event);        mState = newState;    }}

private void sync() {    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();    if (lifecycleOwner == null) {        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"                                        + "garbage collected. It is too late to change lifecycle state.");    }    while (!isSynced()) {        mNewEventOccurred = false;        // no need to check eldest for nullability, because isSynced does it for us.        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {            backwardPass(lifecycleOwner);        }        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();        if (!mNewEventOccurred && newest != null            && mState.compareTo(newest.getValue().mState) > 0) {            forwardPass(lifecycleOwner);        }    }    mNewEventOccurred = false;}

private void backwardPass(LifecycleOwner lifecycleOwner) {    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =        mObserverMap.descendingIterator();    while (descendingIterator.hasNext() && !mNewEventOccurred) {        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();        ObserverWithState observer = entry.getValue();        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred                && mObserverMap.contains(entry.getKey()))) {            Event event = downEvent(observer.mState);            pushParentState(getStateAfter(event));            observer.dispatchEvent(lifecycleOwner, event);            popParentState();        }    }} 
private void forwardPass(LifecycleOwner lifecycleOwner) {     Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =         mObserverMap.iteratorWithAdditions();     while (ascendingIterator.hasNext() && !mNewEventOccurred) {         Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();         ObserverWithState observer = entry.getValue();         while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred                 && mObserverMap.contains(entry.getKey()))) {             pushParentState(observer.mState);             observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));             popParentState();         }     } }

 private static Event downEvent(State state) {     switch (state) {         case INITIALIZED:             throw new IllegalArgumentException();         case CREATED:             return ON_DESTROY;         case STARTED:             return ON_STOP;         case RESUMED:             return ON_PAUSE;         case DESTROYED:             throw new IllegalArgumentException();     }     throw new IllegalArgumentException("Unexpected state value " + state); }

private static Event upEvent(State state) {    switch (state) {        case INITIALIZED:        case DESTROYED:            return ON_CREATE;        case CREATED:            return ON_START;        case STARTED:            return ON_RESUME;        case RESUMED:            throw new IllegalArgumentException();    }    throw new IllegalArgumentException("Unexpected state value " + state);}

static LifecycleEventObserver lifecycleEventObserver(Object object) {    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;    if (isLifecycleEventObserver && isFullLifecycleObserver) {        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,                                                (LifecycleEventObserver) object);    }    if (isFullLifecycleObserver) {        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);    }

    if (isLifecycleEventObserver) {        return (LifecycleEventObserver) object;    }
    final Class<?> klass = object.getClass();    int type = getObserverConstructorType(klass);    if (type == GENERATED_CALLBACK) {        List<Constructor<? extends GeneratedAdapter>> constructors =            sClassToAdapters.get(klass);        if (constructors.size() == 1) {            GeneratedAdapter generatedAdapter = createGeneratedAdapter(                constructors.get(0), object);            return new SingleGeneratedAdapterObserver(generatedAdapter);        }        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];        for (int i = 0; i < constructors.size(); i++) {            adapters[i] = createGeneratedAdapter(constructors.get(i), object);        }        return new CompositeGeneratedAdaptersObserver(adapters);    }    return new ReflectiveGenericLifecycleObserver(object);}

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {    private final Object mWrapped;    private final CallbackInfo mInfo;
    ReflectiveGenericLifecycleObserver(Object wrapped) {        mWrapped = wrapped;        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());    }
    @Override    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {        mInfo.invokeCallbacks(source, event, mWrapped);    }}

CallbackInfo getInfo(Class<?> klass) {    CallbackInfo existing = mCallbackMap.get(klass);    if (existing != null) {        return existing;    }    existing = createInfo(klass, null);    return existing;}

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {    Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();    ...    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);    for (Method method : methods) {        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);        if (annotation == null) {            continue;        }        hasLifecycleMethods = true;        Class<?>[] params = method.getParameterTypes();        int callType = CALL_TYPE_NO_ARG;        if (params.length > 0) {            callType = CALL_TYPE_PROVIDER;            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {                throw new IllegalArgumentException(                    "invalid parameter type. Must be one and instanceof LifecycleOwner");            }        }        Lifecycle.Event event = annotation.value();

        if (params.length > 1) {            callType = CALL_TYPE_PROVIDER_WITH_EVENT;            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {                throw new IllegalArgumentException(                    "invalid parameter type. second arg must be an event");            }            if (event != Lifecycle.Event.ON_ANY) {                throw new IllegalArgumentException(                    "Second arg is supported only for ON_ANY value");            }        }        if (params.length > 2) {            throw new IllegalArgumentException("cannot have more than 2 params");        }        MethodReference methodReference = new MethodReference(callType, method);        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);    }    CallbackInfo info = new CallbackInfo(handlerToEvent);    mCallbackMap.put(klass, info);    mHasLifecycleMethods.put(klass, hasLifecycleMethods);    return info;}

static class CallbackInfo {    final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;    final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
    CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {        mHandlerToEvent = handlerToEvent;        mEventToHandlers = new HashMap<>();        for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {            Lifecycle.Event event = entry.getValue();            List<MethodReference> methodReferences = mEventToHandlers.get(event);            if (methodReferences == null) {                methodReferences = new ArrayList<>();                mEventToHandlers.put(event, methodReferences);            }            methodReferences.add(entry.getKey());        }    }
    @SuppressWarnings("ConstantConditions")    void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {        invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);        invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,                              target);    }
    private static void invokeMethodsForEvent(List<MethodReference> handlers,                                              LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {        if (handlers != null) {            for (int i = handlers.size() - 1; i >= 0; i--) {                handlers.get(i).invokeCallback(source, event, mWrapped);            }        }    }}

static final class MethodReference {    final int mCallType;    final Method mMethod;
    MethodReference(int callType, Method method) {        mCallType = callType;        mMethod = method;        mMethod.setAccessible(true);    }
    void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {        //noinspection TryWithIdenticalCatches        try {            switch (mCallType) {                case CALL_TYPE_NO_ARG:                    mMethod.invoke(target);                    break;                case CALL_TYPE_PROVIDER:                    mMethod.invoke(target, source);                    break;                case CALL_TYPE_PROVIDER_WITH_EVENT:                    mMethod.invoke(target, source, event);                    break;            }        } catch (InvocationTargetException e) {            throw new RuntimeException("Failed to call observer method", e.getCause());        } catch (IllegalAccessException e) {            throw new RuntimeException(e);        }    }    ...}

lifecycleOwner.getLifecycle().addObserver(new MyObserver());

MutableLiveData<String> liveString = new MutableLiveData<>();liveString.observe(mOwner, new Observer<String>() {    @Override    public void onChanged(@Nullable final String s) {        Log.d(TAG, "onChanged() called with: s = [" + s + "]");    }});
liveString.setValue("LiveData使用案例");    

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

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull    final LifecycleOwner mOwner;
    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {        super(observer);        mOwner = owner;    }
    @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());    }
    @Override    boolean isAttachedTo(LifecycleOwner owner) {        return mOwner == owner;    }
    @Override    void detachObserver() {        mOwner.getLifecycle().removeObserver(this);    }}

private abstract class ObserverWrapper {    final Observer<? super T> mObserver;    boolean mActive;    int mLastVersion = START_VERSION;
    ObserverWrapper(Observer<? super T> observer) {        mObserver = observer;    }
    abstract boolean shouldBeActive();
    boolean isAttachedTo(LifecycleOwner owner) {        return false;    }
    void detachObserver() {    }
    void activeStateChanged(boolean newActive) {        if (newActive == mActive) {            return;        }        // immediately set active state, so we'd never dispatch anything to inactive        // owner        mActive = newActive;        boolean wasInactive = LiveData.this.mActiveCount == 0;        LiveData.this.mActiveCount += mActive ? 1 : -1;        if (wasInactive && mActive) {            onActive();        }        if (LiveData.this.mActiveCount == 0 && !mActive) {            onInactive();        }        if (mActive) {            dispatchingValue(this);        }    }}

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

protected void postValue(T value) {    boolean postTask;    synchronized (mDataLock) {        postTask = mPendingData == NOT_SET;        mPendingData = value;    }    if (!postTask) {        return;    }    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);}private final Runnable mPostValueRunnable = new Runnable() {    @SuppressWarnings("unchecked")    @Override    public void run() {        Object newValue;        synchronized (mDataLock) {            newValue = mPendingData;            mPendingData = NOT_SET;        }        setValue((T) newValue);    }};

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;}

@Testpublic void testSetValueDuringSetValue() {    mOwner.handleLifecycleEvent(ON_START);    final Observer observer1 = spy(new Observer<String>() {        @Override        public void onChanged(String o) {            assertThat(mInObserver, is(false));            mInObserver = true;            if (o.equals(("bla"))) {                mLiveData.setValue("gt");            }            mInObserver = false;        }    });    final Observer observer2 = spy(new FailReentranceObserver());    mLiveData.observe(mOwner, observer1);    mLiveData.observe(mOwner, observer2);    mLiveData.setValue("bla");    verify(observer1, Mockito.atMost(2))        .onChanged("gt");    verify(observer2, Mockito.atMost(2))        .onChanged("gt");}

 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); }

public class MyViewModel extends ViewModel {    private MutableLiveData<List<User>> users;    public LiveData<List<User>> getUsers() {        if (users == null) {            users = new MutableLiveData<List<User>>();            loadUsers();        }        return users;    }
    private void loadUsers() {        // Do an asynchronous operation to fetch users.    }}public class MyActivity extends AppCompatActivity {    public void onCreate(Bundle savedInstanceState) {        MyViewModel model = new ViewModelProvider(this).get(MyViewModel.class);    }}

/**
 * Creates {@code ViewModelProvider}. This will create {@code ViewModels} * and retain them in a store of the given {@code ViewModelStoreOwner}. * <p> * This method will use the * {@link HasDefaultViewModelProviderFactory#getDefaultViewModelProviderFactory() default factory} * if the owner implements {@link HasDefaultViewModelProviderFactory}. Otherwise, a * {@link NewInstanceFactory} will be used. */public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {    this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory         ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()         : NewInstanceFactory.getInstance());}/** * Creates {@code ViewModelProvider}, which will create {@code ViewModels} via the given * {@code Factory} and retain them in the given {@code store}. * * @param store   {@code ViewModelStore} where ViewModels will be stored. * @param factory factory a {@code Factory} which will be used to instantiate *                new {@code ViewModels} */public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {    mFactory = factory;    mViewModelStore = store;}

@NonNull@MainThreadpublic <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);}@MainThreadpublic <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {    ViewModel viewModel = mViewModelStore.get(key);

    if (modelClass.isInstance(viewModel)) {        if (mFactory instanceof OnRequeryFactory) {            ((OnRequeryFactory) mFactory).onRequery(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;}

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

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

public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
    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 (mDefaultFactory == null) {        mDefaultFactory = new SavedStateViewModelFactory(            getApplication(),            this,            getIntent() != null ? getIntent().getExtras() : null);    }    return mDefaultFactory;}

public SavedStateViewModelFactory(@NonNull Application application,                                  @NonNull SavedStateRegistryOwner owner,                                  @Nullable Bundle defaultArgs) {    mSavedStateRegistry = owner.getSavedStateRegistry();    mLifecycle = owner.getLifecycle();    mDefaultArgs = defaultArgs;    mApplication = application;    mFactory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);}

@Overridepublic <T extends ViewModel> T create(@NonNull String key, @NonNull Class<T> modelClass) {    boolean isAndroidViewModel = AndroidViewModel.class.isAssignableFrom(modelClass);    Constructor<T> constructor;    if (isAndroidViewModel) {        constructor = findMatchingConstructor(modelClass, ANDROID_VIEWMODEL_SIGNATURE);    } else {        constructor = findMatchingConstructor(modelClass, VIEWMODEL_SIGNATURE);    }    // doesn't need SavedStateHandle    if (constructor == null) {        return mFactory.create(modelClass);    }
    SavedStateHandleController controller = SavedStateHandleController.create(        mSavedStateRegistry, mLifecycle, key, mDefaultArgs);    try {        T viewmodel;        if (isAndroidViewModel) {            viewmodel = constructor.newInstance(mApplication, controller.getHandle());        } else {            viewmodel = constructor.newInstance(controller.getHandle());        }        viewmodel.setTagIfAbsent(TAG_SAVED_STATE_HANDLE_CONTROLLER, controller);        return viewmodel;    } catch (IllegalAccessException e) {        throw new RuntimeException("Failed to access " + modelClass, e);    } catch (InstantiationException e) {        throw new RuntimeException("A " + modelClass + " cannot be instantiated.", e);    } catch (InvocationTargetException e) {        throw new RuntimeException("An exception happened in constructor of "                                   + modelClass, e.getCause());    }}

public static class AndroidViewModelFactory extends ViewModelProvider.NewInstanceFactory {
    ...    @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);    }}

public static class NewInstanceFactory implements Factory {    ...
    @SuppressWarnings("ClassNewInstance")    @NonNull    @Override    public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {        //noinspection TryWithIdenticalCatches        try {            return modelClass.newInstance();        } catch (InstantiationException e) {            throw new RuntimeException("Cannot create an instance of " + modelClass, e);        } catch (IllegalAccessException e) {            throw new RuntimeException("Cannot create an instance of " + modelClass, e);        }    }}

interface OnPauses extends LifecycleObserver {    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)    void onPause();
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)    void onPause(LifecycleOwner owner);}
interface OnPauseResume extends LifecycleObserver {    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)    void onPause();
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)    void onResume();}
class Impl1 implements OnPauses, OnPauseResume {
    List<String> mLog;
    Impl1(List<String> log) {        mLog = log;    }
    @Override    public void onPause() {        mLog.add("onPause_0");    }
    @Override    public void onResume() {        mLog.add("onResume");    }
    @Override    public void onPause(LifecycleOwner owner) {        mLog.add("onPause_1");    }}

public class GeneratedAdaptersTest_TestObserver_LifecycleAdapter implements GeneratedAdapter {  final GeneratedAdaptersTest.TestObserver mReceiver;
  GeneratedAdaptersTest_TestObserver_LifecycleAdapter(GeneratedAdaptersTest.TestObserver receiver) {    this.mReceiver = receiver;  }
  @Override  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,      MethodCallsLogger logger) {    boolean hasLogger = logger != null;    if (onAny) {      if (!hasLogger || logger.approveCall("onAny", 1)) {        mReceiver.onAny();      }      return;    }    if (event == Lifecycle.Event.ON_CREATE) {      if (!hasLogger || logger.approveCall("onCreate", 1)) {        mReceiver.onCreate();      }      return;    }  }}